/*

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

*

*/

// alarmalertwidget_p.cpp

// System includes

#include <QApplication>

#include <QGesture>

#include <QGestureEvent>

#include <QDebug>

#include <QGraphicsSceneMouseEvent>

#include <QTranslator>

#include <hbdocumentloader.h>

#include <hbpushbutton.h>

#include <hblabel.h>

#include <hbinstance.h>

#include <hbextendedlocale.h>

#include <hbi18ndef.h>

#include <hbapplication.h>

// User includes

#include "alarmalertwidget_p.h"

#include "alarmalert.h"

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

// AlarmAlertDialogPrivate::AlarmAlertDialogPrivate

// rest of the details are commented in the header

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

//

AlarmAlertDialogPrivate::AlarmAlertDialogPrivate(const QVariantMap &parameters):

	mClosedByClient(false),

	mIsSilenceButton(false)

{

    // Extract all the parameters sent by the client

    parseAndFetchParams(parameters);

	// Set the dismiss policy and timeout property

	setDismissPolicy(HbPopup::NoDismiss);

    setTimeout(HbPopup::NoTimeout);

    // Initialize the user response

	mUserResponse = Other;

	/*if (isScreenLocked()) {

	    setupSwipeUI();

	} else {

	    setupNormalUI();

	}*/

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

	mTranslator = new QTranslator;

	QString lang = QLocale::system().name();

	QString path = "Z:/resource/qt/translations/";

	bool loaded = mTranslator->load("alarmui_en_GB",":/translations");

	// TODO: Load the appropriate .qm file based on locale

	//bool loaded = mTranslator->load("alarmui_" + lang, path);

	HbApplication::instance()->installTranslator(mTranslator);

	setupNormalUI();

	// Find the content widget and set it to self

	QGraphicsWidget *contentWidget = mDocLoader->findWidget("content");

	Q_ASSERT_X(contentWidget, "alarmalertwidget_p.cpp", "Unable to find content widget");

    setContentWidget(contentWidget);

    // Resize the dialog to accomodate the content widget

    setPreferredSize(contentWidget->minimumSize());

    // TODO: Gestures not working. Integrate once support is available from Qt

    grabGesture(Qt::SwipeGesture);

}

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

// AlarmAlertDialogPrivate::~AlarmAlertDialogPrivate

// rest of the details are commented in the header

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

//

AlarmAlertDialogPrivate::~AlarmAlertDialogPrivate()

{

    // Cleanup

    if (mDocLoader) {

        delete mDocLoader;

    }

    // Cancel any ongoing animations

    HbEffect::cancel(mSlider, "slideDownPortrait", false, false, false);

    HbEffect::cancel(mSlider, "slideDownLandscape", false, false, false);

    // Remove the effect

    HbEffect::remove(mSlider);

	// Remove the translator

	HbApplication::instance()->removeTranslator(mTranslator);

	if (mTranslator) {

		delete mTranslator;

		mTranslator = 0;

	}

}

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

// AlarmAlertDialogPrivate::setDeviceDialogParameters

// rest of the details are commented in the header

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

//

bool AlarmAlertDialogPrivate::setDeviceDialogParameters(const QVariantMap &parameters)

{

    Q_UNUSED(parameters);

    //TODO: Handle parameters to be set

    return 0;

}

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

// AlarmAlertDialogPrivate::deviceDialogError

// rest of the details are commented in the header

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

//

int AlarmAlertDialogPrivate::deviceDialogError() const

{

    // TODO: Return any errors that might have occured

    return 0;

}

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

// AlarmAlertDialogPrivate::AlarmAlertDialogPrivate

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::closeDeviceDialog(bool byClient)

{

    Q_UNUSED(byClient);

    mClosedByClient = byClient;

	close();

}

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

// AlarmAlertDialogPrivate::deviceDialogWidget

// rest of the details are commented in the header

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

//

HbDialog *AlarmAlertDialogPrivate::deviceDialogWidget() const

{

    return const_cast<AlarmAlertDialogPrivate*> (this);

}

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

// AlarmAlertDialogPrivate::showEvent

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::showEvent(QShowEvent *event)

{

	HbDialog::showEvent(event);

	QVariantMap param;

	param.insert(alarmCommand, mUserResponse);

	//emit deviceDialogData(param);

}

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

// AlarmAlertDialogPrivate::closeEvent

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::closeEvent(QCloseEvent *event)

{

    // Forward the call to the base class

	HbDialog::closeEvent(event);

	// Do not notify the client back if the close was initiated by client itself

	if(!mClosedByClient) {

		// Package the user response and send it

		QVariantMap param;

		param.insert(alarmCommand, mUserResponse);

		emit deviceDialogData(param);

	}

	// This signal has to be emitted so that the dialog can be cleaned up later

	emit deviceDialogClosed();

}

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

// AlarmAlertDialogPrivate::animationComplete

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::animationComplete(const HbEffect::EffectStatus &status)

{

    Q_UNUSED(status);

    // Restart the animation effects

	if (Qt::Vertical == hbInstance->orientation()) {

		HbEffect::start(mSlider, "slideDownPortrait", this, "animationComplete");

	} else {

	    HbEffect::start(mSlider, "slideDownLandscape", this, "animationComplete");

	}

}

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

// AlarmAlertDialogPrivate::sceneEvent

// rest of the details are commented in the header

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

//

bool AlarmAlertDialogPrivate::sceneEvent(QEvent *event)

{

    // TODO: Need to handle gestures once they are available

    if (event->type() == QEvent::Gesture) {

        QGestureEvent *gestureEvent =

                static_cast<QGestureEvent*>(event);

        if (const QGesture *gesture = gestureEvent->gesture(Qt::SwipeGesture)) {

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

                event->accept();

                close();

                return true;

            }

            event->accept();

            return true;

        }

    }

    return HbWidget::sceneEvent(event);

}

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

// AlarmAlertDialogPrivate::handleOrientationChange

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::handleOrientationChange ()

{

    // TODO: Need to change this as per the UI concept

    // Might need to disable orientation changes

	bool loadSuccess(false);

	if (Qt::Vertical == hbInstance->orientation()) {

		mDocLoader->load(":/xml/alarmalert.docml", "portrait", &loadSuccess);

		Q_ASSERT_X(loadSuccess, "alarmalertwidget_p.cpp", "Unable to load portrait section");

	} else {

		mDocLoader->load(":/xml/alarmalert.docml", "landscape", &loadSuccess);

		Q_ASSERT_X(loadSuccess, "alarmalertwidget_p.cpp", "Unable to load landscape section");

	}

}

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

// AlarmAlertDialogPrivate::snoozed

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::snoozed()

{

	mUserResponse = Snooze;

	close();

}

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

// AlarmAlertDialogPrivate::silenced

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::silenced()

{

	if (mIsSilenceButton) {

		mUserResponse = Silence;

		mSnoozeButton->setText(hbTrId("txt_calendar_button_alarm_snooze"));

		mIsSilenceButton = false;

		QVariantMap param;

		param.insert(alarmCommand, mUserResponse);

		emit deviceDialogData(param);

	}else {

		mUserResponse = Snooze;

		close();

	}

}

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

// AlarmAlertDialogPrivate::dismissed

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::dismissed()

{

	mUserResponse = Stop;

	close();

}

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

// AlarmAlertDialogPrivate::parseAndFetchParams

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::parseAndFetchParams(const QVariantMap &parameters)

{

    // Iterate thru the list and extract all relevant parameters

    QVariantMap::const_iterator iter = parameters.constBegin();

    int count = parameters.size();

    while (iter != parameters.constEnd()) {

        QString key(iter.key());

        if (alarmSubject == key) {

            mSubject = iter.value().toString();

        } else if (alarmLocation == key) {

            mLocation = iter.value().toString();

        } else if (alarmDateTime == key) {

            mAlarmTime = iter.value().toDateTime();

        } else if (alarmType == key) {

            mIsClockAlarm = iter.value().toBool();

        } else if (alarmCanSnooze == key) {

            mCanSnooze = iter.value().toBool();

        } else if (alarmRingingType == key) {

            mIsSilent = iter.value().toBool();

        } else {

            break;

        }

        iter++;

    }

}

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

// AlarmAlertDialogPrivate::setupSwipeUI

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::setupSwipeUI()

{

    // Connect to orientation change signals

    QList<HbMainWindow*> windowList = hbInstance->allMainWindows();

    mMainWindow = windowList.at(0);

    Q_ASSERT_X(mMainWindow, "alarmalertwidget_p.cpp", "Unable to get the main window");

    connect(mMainWindow, SIGNAL(aboutToChangeOrientation()), this, SLOT(handleOrientationChange()));

    // Load the docml file to get the content widget for the dialog

    mDocLoader = new HbDocumentLoader();

    bool loadSuccess = false;

    mDocLoader->load(alarmSwipeUIDocml, &loadSuccess);

    Q_ASSERT_X(loadSuccess, "alarmalertwidget_p.cpp", "Unable to load docml");

    // Get the reference to the slider widget

    mSlider = mDocLoader->findWidget("sliderIcon");

    Q_ASSERT_X(mSlider, "alarmalertwidget_p.cpp", "Unable to find slider widget");

    mAlarmDescription = qobject_cast<HbLabel*> (mDocLoader->findWidget("alarmDescription"));

    Q_ASSERT_X(mAlarmDescription, "alarmalertwidget_p.cpp", "Unable to find alarm description label");

    mAlarmDescription->setPlainText(mSubject);

    mAlarmDateTime = qobject_cast<HbLabel*> (mDocLoader->findWidget("alarmTime"));

    Q_ASSERT_X(mAlarmDateTime, "alarmalertwidget_p.cpp", "Unable to find alarm time label");

    mAlarmIcon = qobject_cast<HbLabel*> (mDocLoader->findWidget("alarmIcon"));

    Q_ASSERT_X(mAlarmIcon, "alarmalertwidget_p.cpp", "Unable to find alarm icon");

    if (!mIsClockAlarm) {

        mAlarmIcon->setIcon(HbIcon(":/image/calendarAlarm"));

    }

    // Set the time to the time label

    HbExtendedLocale locale;

    mAlarmDateTime->setPlainText(locale.format(mAlarmTime.time(), r_qtn_time_usual));

    // Add the required effects.

    HbEffect::add(mSlider,

                  QString(":/effect/animate_portrait.fxml"),

                  "slideDownPortrait");

    HbEffect::add(mSlider,

                  QString(":/effect/animate_landscape.fxml"),

                  "slideDownLandscape");

    // Based on the orientation, load the appropriate sections and animations

    if (Qt::Vertical == hbInstance->orientation()) {

        mDocLoader->load(":/xml/alarmalert.docml", "portrait", &loadSuccess);

        Q_ASSERT_X(loadSuccess, "alarmalertwidget_p.cpp", "Unable to load portrait section");

        HbEffect::start(mSlider, "slideDownPortrait", this, "animationComplete");

    } else {

        mDocLoader->load(":/xml/alarmalert.docml", "landscape", &loadSuccess);

        Q_ASSERT_X(loadSuccess, "alarmalertwidget_p.cpp", "Unable to load landscape section");

        HbEffect::start(mSlider, "slideDownLandscape", this, "animationComplete");

    }

    // Get the reference to the snooze button

    HbPushButton *snoozeButton = qobject_cast<HbPushButton*> (mDocLoader->findWidget("snoozeButton"));

    Q_ASSERT_X(snoozeButton, "alarmalertwidget_p.cpp", "Unable to find snooze button");

    connect(snoozeButton, SIGNAL(clicked()), this, SLOT(snoozed()));

    if (!mCanSnooze) {

        snoozeButton->hide();

    }

}

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

// AlarmAlertDialogPrivate::setupNormalUI

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::setupNormalUI()

{

    // Load the docml file to get the content widget for the dialog

    mDocLoader = new HbDocumentLoader();

    bool loadSuccess = false;

    mDocLoader->load(alarmNormalUIDocml, &loadSuccess);

    Q_ASSERT_X(loadSuccess, "alarmalertwidget_p.cpp", "Unable to load docml");

    mAlarmDescription = qobject_cast<HbLabel*> (mDocLoader->findWidget("alarmDescription"));

    Q_ASSERT_X(mAlarmDescription, "alarmalertwidget_p.cpp", "Unable to find alarm description label");

    mAlarmDescription->setPlainText(mSubject);

    mAlarmDateTime = qobject_cast<HbLabel*> (mDocLoader->findWidget("alarmTime"));

    Q_ASSERT_X(mAlarmDateTime, "alarmalertwidget_p.cpp", "Unable to find alarm time label");

    mAlarmIcon = qobject_cast<HbLabel*> (mDocLoader->findWidget("alarmIcon"));

    Q_ASSERT_X(mAlarmIcon, "alarmalertwidget_p.cpp", "Unable to find alarm icon");

    if (!mIsClockAlarm) {

        mAlarmIcon->setIcon(HbIcon(":/image/calendarAlarm"));

    }

    // Set the time to the time label

    HbExtendedLocale locale = HbExtendedLocale::system();

    mAlarmDateTime->setPlainText(

    		hbTrId("txt_calendar_info_alarm_start_time").arg(

    				locale.format(mAlarmTime.time(), r_qtn_time_usual)));

    // TODO: Based on the orientation, load the appropriate sections and animations

    if (Qt::Vertical == hbInstance->orientation()) {

    } else {

    }

    // Get the reference to the stop button

    HbPushButton *stopButton = qobject_cast<HbPushButton*> (mDocLoader->findWidget("stopButton"));

    Q_ASSERT_X(stopButton, "alarmalertwidget_p.cpp", "Unable to find stop button");

    connect(stopButton, SIGNAL(clicked()), this, SLOT(dismissed()));

    if (mIsClockAlarm) {

    	handleClockAlarms();

    }else {

    	handleCalendarAlarms();

    }

    QList<HbMainWindow*> windowList = hbInstance->allMainWindows();

    mMainWindow = windowList.at(0);

    QRectF screenRect = mMainWindow->rect();

    setPreferredPos(QPointF(screenRect.width()/2, screenRect.height()/2), HbPopup::Center);

}

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

// AlarmAlertDialogPrivate::handleClockAlarms

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::handleClockAlarms()

{

	// Get the reference to the snooze button

	HbPushButton *snoozeButton = qobject_cast<HbPushButton*> (mDocLoader->findWidget("snoozeButton"));

	Q_ASSERT_X(snoozeButton, "alarmalertwidget_p.cpp", "Unable to find snooze button");

	connect(snoozeButton, SIGNAL(clicked()), this, SLOT(snoozed()));

	if (!mCanSnooze) {

		snoozeButton->hide();

	}

}

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

// AlarmAlertDialogPrivate::handleCalendarAlarms

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::handleCalendarAlarms()

{

	mSnoozeButton = qobject_cast<HbPushButton*> (mDocLoader->findWidget("snoozeButton"));

	Q_ASSERT_X(mSnoozeButton, "alarmalertwidget_p.cpp", "Unable to find snooze button");

	connect(mSnoozeButton, SIGNAL(clicked()), this, SLOT(silenced()));

	if(!mIsSilent) {

		mSnoozeButton->setText(hbTrId("txt_calendar_button_alarm_silence"));

		mIsSilenceButton = true;

	}

	// Hide the snooze button if the alarm cannot be snoozed

	if (!mCanSnooze) {

		mSnoozeButton->hide();

	}

}

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

// AlarmAlertDialogPrivate::isScreenLocked

// rest of the details are commented in the header

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

//

bool AlarmAlertDialogPrivate::isScreenLocked()

{

    // TODO: Replace with actual API which gets the screen lock status

    return false;

}

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

// AlarmAlertDialogPrivate::mousePressEvent

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

    // TODO: Must be removed once gestures are available

    mTapPoint = event->pos();

    qDebug() << "Tap event";

}

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

// AlarmAlertDialogPrivate::mouseMoveEvent

// rest of the details are commented in the header

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

//

void AlarmAlertDialogPrivate::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

{