/*
* Copyright (c) 2008 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:
*
*/

#include <QGraphicsSceneMouseEvent>

#include <HbStyle>
#include <HbStyleLoader>
#include <HbFrameItem>
#include <HbFrameDrawer>
#include <HbIconItem>
#include <HbTextItem>
#include <HbTouchArea>
#include <HbInstantFeedback>
#include <HbTapGesture>

#include "dialerwidget.h"

#ifdef Q_OS_SYMBIAN
    #include "dialerwidgetengine.h"
    #include "qtphonelog.h"
    #include <xqappmgr.h>
    #include <xqservicerequest.h>
    #include <xqpublishandsubscribeutils.h>
    #include <xqrequestinfo.h>
    #include <xqaiwdecl.h>
#else
    #define PHONE_TRACE
#endif

const QLatin1String KDialerWidgetIconNormal("qtg_graf_hs_dialer_normal");
const QLatin1String KDialerWidgetIconPressed("qtg_graf_hs_dialer_pressed");
const QLatin1String KDialerWidgetMissedCallBadge("qtg_fr_shortcut_badge_bg");
const QLatin1String KDialerWidgetWidgetml(":/resource/dialerwidget.widgetml");
const QLatin1String KDialerWidgetCss(":/resource/dialerwidget.css");
const QLatin1String KDialerWidgetNormalLayout("normal");
const QLatin1String KDialerWidgetMissedCallLayout("missed_call");
const int KDialerWidgetMaxBadgeTextLenght = 2; // displayable
// update corresponding values also in css side
const qreal KDialerWidgetNormalSize = 12.0; // unit
const qreal KDialerWidgetMissedCallSize = 12.75; // unit

/*!
    \class DialerWidget

    \ingroup group_dialerwidgetplugin
    \brief Implementation for the homescreen dialer launcher.

*/

/*!
    Constructs dialer widget with given \a parent and given window \a flags.
*/
DialerWidget::DialerWidget(QGraphicsItem *parent, Qt::WindowFlags flags)
  : HbWidget(parent, flags),
    m_background(0),
    m_badgeBackground(0),
    m_text(0),
    m_touchArea(0),
    m_engine(0)
{   
    PHONE_TRACE
    createPrimitives();

    HbStyleLoader::registerFilePath(KDialerWidgetWidgetml);
    HbStyleLoader::registerFilePath(KDialerWidgetCss);

    setLayout(KDialerWidgetNormalLayout);
}

/*!
    Destructor.
*/
DialerWidget::~DialerWidget()
{
    HbStyleLoader::unregisterFilePath(KDialerWidgetWidgetml);
    HbStyleLoader::unregisterFilePath(KDialerWidgetCss);
}

/*!
    Lenght of badge text.
*/
int DialerWidget::badgeTextLenght() const
{
    return m_text->text().length();
}

/*!
    Layout name.
*/
QString DialerWidget::layoutName() const
{
    return m_layoutName;
}

/*!
    \fn void DialerWidget::startDialer()

    Starts dialer widget via view activation service.
*/
void DialerWidget::startDialer()
{
    PHONE_TRACE
#ifdef Q_OS_SYMBIAN

    QList<QVariant> args;
    QString service;
    QString interface;
    QString operation;

    service = "logs";
    interface = XQI_LOGS_VIEW;
    operation = XQOP_LOGS_SHOW;
    QVariantMap map;
    map.insert(XQLOGS_VIEW_INDEX, QVariant(int(XQService::LogsViewAll)));
    map.insert(XQLOGS_SHOW_DIALPAD, QVariant(true));
    map.insert(XQLOGS_DIALPAD_TEXT, QVariant(QString()));
    args.append(QVariant(map));

    XQApplicationManager appManager;
    QScopedPointer<XQAiwRequest> request(appManager.create(service, interface, operation, false));
    if (request == NULL) {
        PHONE_TRACE1("service not found");
        return;
    }
    request->setArguments(args);
    request->setSynchronous(false);
    bool ret = request->send();
    PHONE_TRACE2("request sent successfully:", ret);
#endif

}

void DialerWidget::onInitialize()
{
    PHONE_TRACE
#ifdef Q_OS_SYMBIAN
    QT_TRY{
        // Engine construction is 2 phased 
        m_engine = new DialerWidgetEngine();
        connect(m_engine, SIGNAL( exceptionOccured(const int&) )
                ,this, SLOT( onEngineException(const int&) ) );
        
        connect( m_engine, SIGNAL(missedCallsCountChanged(const int&)),
                        this, SLOT(onMissedCallsCountChange(const int&)));
        
        if(!m_engine->initialize()){
            //engine construction failed. Give up.
            emit error();
            return;
            }
        }
    QT_CATCH(...){
        emit error();
    }
#endif
}

/*!
    \fn void DialerWidget::onShow()

    Shows the widget
*/
void DialerWidget::onShow()
{
    PHONE_TRACE
}

/*!
    \fn void DialerWidget::onHide()

    Hides the widget
*/
void DialerWidget::onHide()
{
    PHONE_TRACE
}

/*!
    \fn void DialerWidget::onUninitialize()

    Uninitializes the widget
*/
void DialerWidget::onUninitialize()
{
    PHONE_TRACE
}

void DialerWidget::onEngineException(const int& exc)
{
    Q_UNUSED(exc);
    emit error();
}

void DialerWidget::onMissedCallsCountChange(const int& count)
{
    if (count){
        QString newText = QLocale::system().toString(count);

        if (newText.length()>KDialerWidgetMaxBadgeTextLenght) {
            newText = QLatin1String("*");
        }

        bool doRepolish = (m_text->text().length() != newText.length());

        m_badgeBackground->setVisible(true);

        m_text->setText(newText);

        m_text->setVisible(true);

        if (doRepolish) {
            repolish();
        }

        setLayout(KDialerWidgetMissedCallLayout);
    } else {
        m_badgeBackground->setVisible(false);

        m_text->setVisible(false);

        setLayout(KDialerWidgetNormalLayout);
    }
}

void DialerWidget::gestureEvent(QGestureEvent *event)
{
    HbTapGesture *gesture = qobject_cast<HbTapGesture *>(event->gesture(Qt::TapGesture));
    if (gesture) {
        switch (gesture->state()) {
            case Qt::GestureStarted:
                setBackgroundToPressed();
                break;            
            case Qt::GestureCanceled:
                setBackgroundToNormal();
                break;
            case Qt::GestureFinished:
                setBackgroundToNormal();
                if (gesture->tapStyleHint() == HbTapGesture::Tap) {
                    HbInstantFeedback::play(HbFeedback::Basic);
                    startDialer();
                }
                break;
            default:
                break;
        }
    }
}

QRectF DialerWidget::boundingRect() const
{
    return childrenBoundingRect();
}

QPainterPath DialerWidget::shape() const
{
    QPainterPath path;
    path.addRect(boundingRect());
    return path;
}

void DialerWidget::createPrimitives()
{   
    // Background
    if (!m_background) {
        HbFrameDrawer *drawer = new HbFrameDrawer(
            KDialerWidgetIconNormal, HbFrameDrawer::OnePiece);
        m_background = new HbFrameItem(drawer, this);
        style()->setItemName(m_background, QLatin1String("background"));
    }
    
    // Badge background
    if (!m_badgeBackground) {
        HbFrameDrawer *badgedrawer = new HbFrameDrawer(
            KDialerWidgetMissedCallBadge, HbFrameDrawer::ThreePiecesHorizontal);
        m_badgeBackground = new HbFrameItem(badgedrawer, this);
        style()->setItemName(m_badgeBackground, QLatin1String("badgeBackground"));
        m_badgeBackground->setVisible( false );
    }

    // Text
    if (!m_text) {
        m_text = new HbTextItem(this);
        style()->setItemName(m_text, QLatin1String("badgeText"));
        m_text->setVisible(false);
    }

    // Touch area
    if (!m_touchArea) {
        m_touchArea = new HbTouchArea(this);
        m_touchArea->setFlag(QGraphicsItem::ItemIsFocusable);
        style()->setItemName(m_touchArea, QLatin1String("touchArea"));
        setFiltersChildEvents(true);
        m_touchArea->grabGesture(Qt::TapGesture);
    }
}

void DialerWidget::setBackgroundToNormal()
{
    if (m_background) {
        m_background->frameDrawer().
            setFrameGraphicsName(KDialerWidgetIconNormal);
    }
}

void DialerWidget::setBackgroundToPressed()
{
    if (m_background) {
        m_background->frameDrawer().
            setFrameGraphicsName(KDialerWidgetIconPressed);
    }
}

void DialerWidget::setLayout(const QString& layoutName)
{
    if (layoutName==m_layoutName) {
        return;
    }

    qreal unit = HbDeviceProfile::profile(this).unitValue();

    prepareGeometryChange();

    if (layoutName==KDialerWidgetMissedCallLayout) {
        resize(KDialerWidgetMissedCallSize*unit,
               KDialerWidgetMissedCallSize*unit);
    } else {
        resize(KDialerWidgetNormalSize*unit,
               KDialerWidgetNormalSize*unit);
    }

    m_layoutName = layoutName;

    repolish();
}