/*

*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include <QObject>

#include <qglobal.h>

#include <QApplication>

#include <QLatin1String>

#include <QLocale>

#include <QIcon>

#include <QFileInfo>

#include <xqaiwdecl.h>

#include <xqservicerequest.h>

#include "xqrequestutil.h"

#include "xqservicelog.h"

#include "xqaiwutils.h"

#include "xqaiwservicedriver.h"

// Constants

XQAiwServiceDriver::XQAiwServiceDriver(const XQAiwInterfaceDescriptor& descriptor, const QString &operation)

    : XQAiwRequestDriver(),

      currentRequest(NULL),

      asyncErrorSet(false)

    {

    mErrorMsg = "";

    mDescr = descriptor; 

    mOperation = operation; 

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::XQAiwServiceDriver: %s %s,%x",

                          qPrintable(mDescr.interfaceName()),

                          qPrintable(mOperation),

                          mDescr.property(XQAiwInterfaceDescriptor::ImplementationId).toInt());

    // Allocate QtHighway request

    currentRequest = new XQServiceRequest(mDescr, mOperation);

    }

XQAiwServiceDriver::~XQAiwServiceDriver()

{

    XQSERVICE_DEBUG_PRINT("~XQAiwServiceDriver::XQAiwServiceDriver");

    // Disconnect error

    if (asyncErrorSet)

    {

        disconnect(currentRequest, SIGNAL(requestCompleted(const QVariant&)), this, SLOT(handleAsyncResponse(const QVariant&)));

        disconnect(currentRequest, SIGNAL(requestError(int)), this, SLOT(handleAsyncError(int)));

    }

    delete currentRequest; // Destructor cancels the async request

    XQSERVICE_DEBUG_PRINT("~XQAiwServiceDriver::XQAiwServiceDriver 2");

    removeTranslator();

    currentRequest = NULL;

}

QAction *XQAiwServiceDriver::createAction()

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::createAction");

    if (!qApp)

        return NULL;  // Not supported in non-GUI environments

    installTranslator();

    QString textId = mDescr.customProperty(XQCUSTOM_PROP_AIW_TEXT);

    if (textId.isEmpty())

    {

        // Applye the key name and make it visible to client as indication of

        // missing property ..

        textId = "#missing " + XQCUSTOM_PROP_AIW_TEXT;

    }

    QByteArray ba = textId.toLatin1();

    const char *textPtr = ba.data();

    QString text = qtTrId(textPtr);  // translate

    XQSERVICE_DEBUG_PRINT("Translated text %s", qPrintable(text));

    QAction *action=0;

    QIcon icon;

    QString iconFile = mDescr.customProperty(XQCUSTOM_PROP_AIW_ICON);

    if (!iconFile.isEmpty())

    {

        XQSERVICE_DEBUG_PRINT("QAction with icon and text");

        icon.addFile(iconFile);

        action = new QAction(icon, text, 0);

    }

    else

    {

        XQSERVICE_DEBUG_PRINT("QAction with text");

        action = new QAction(text,0);

    }

    return action;

}

void XQAiwServiceDriver::setArguments(const QList<QVariant> &arguments)

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::setArguments");

    currentRequest->setArguments(arguments);

}

bool XQAiwServiceDriver::send(QVariant& retValue)

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::send>>>");

    XQRequestInfo opt = info();

    currentRequest->setInfo(opt);

    QStringList list;

    bool res = true;

    if (!currentRequest->isSynchronous() && !asyncErrorSet)

    {

        // Async request 

        XQSERVICE_DEBUG_PRINT("request::async send");

        connect(currentRequest, SIGNAL(requestCompleted(const QVariant&)), this, SLOT(handleAsyncResponse(const QVariant&)));

        connect(currentRequest, SIGNAL(requestError(int)), this, SLOT(handleAsyncError(int)));

        asyncErrorSet = true;

    }

    XQSERVICE_DEBUG_PRINT("request::send>>>");

    res = currentRequest->send(retValue);  // Result is valid for sync request only

    XQSERVICE_DEBUG_PRINT("request::send: %d<<<", res);

    mErrorCode = XQRequestUtil::mapError(currentRequest->latestError());

    if (res && !mErrorCode)

    {

        mErrorMsg = "";

    }

    else

    {

        // This is for debugging/trace purposes only,  no need to localize

        mErrorMsg = XQAiwUtils::createErrorMessage(mErrorCode, "XQAiwServiceDriver", "sync send");

    }

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::send: %d<<<", res);

    return res;

}

const QString& XQAiwServiceDriver::lastErrorMessage() const

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::lastErrorMessage: %s", qPrintable(mErrorMsg));

    return mErrorMsg;

}

int XQAiwServiceDriver::lastError() const

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::lastError %d", mErrorCode);

    return mErrorCode;

}

const XQAiwInterfaceDescriptor &XQAiwServiceDriver::descriptor() const 

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::descriptor");

    return mDescr; 

}

void XQAiwServiceDriver::setEmbedded(bool embedded)

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::setEmbedded");

    // Embedded is option

    mEmbedded = embedded;

}

bool XQAiwServiceDriver::isEmbedded() const

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::isEmbedded");

    // Embedded is option

    return mEmbedded;

}

void XQAiwServiceDriver::setBackground(bool background )

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::setBackground");

    mBackground = background;

}

bool XQAiwServiceDriver::isBackground() const

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::isBackground");

    return mBackground;

}

void XQAiwServiceDriver::setOperation(const QString &operation)

{

    XQSERVICE_DEBUG_PRINT("XQAiwRequest::setOperation");

    mOperation = operation;

    currentRequest->setMessage(operation);

}

const QString &XQAiwServiceDriver::operation() const

{

    XQSERVICE_DEBUG_PRINT("XQAiwRequest::operation");

    return mOperation;

}

void XQAiwServiceDriver::setSynchronous(bool synchronous)

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::setSynchronous");

    currentRequest->setSynchronous(synchronous);

}

bool XQAiwServiceDriver::isSynchronous() const

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::isSynchronous");

    return currentRequest->isSynchronous();

}

void XQAiwServiceDriver::setInfo(const XQRequestInfo &info)

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::setInfo");

    currentRequest->setInfo(info);

}

XQRequestInfo XQAiwServiceDriver::info() const

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::info");

    return currentRequest->info();

}

void XQAiwServiceDriver::handleAsyncResponse(const QVariant& value)

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::handleAsyncResponse");

    emit requestOk(value);

}

void XQAiwServiceDriver::handleAsyncError(int err)

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::handleAsyncError");

   mErrorCode = XQRequestUtil::mapError(err);

   mErrorMsg = XQAiwUtils::createErrorMessage(mErrorCode, "XQAiwServiceDriver", "async send");

   emit requestError(mErrorCode, mErrorMsg);

}

bool XQAiwServiceDriver::installTranslator()

{

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::installTranslator");

    if (!qApp)

    {

        XQSERVICE_DEBUG_PRINT("\tNo application context");

        return false;

    }

    // The the name of the resource file containing the text

    QString textFile = mDescr.customProperty(XQCUSTOM_PROP_AIW_TEXT_FILE);

    if (textFile.isEmpty())

    {

        XQSERVICE_DEBUG_PRINT("\tCustom property missing for text file");

        return false;

    }

    // Check if locale has changed since last request

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

    XQSERVICE_DEBUG_PRINT("\tLanguage now is%s", qPrintable(lang));

    if (!this->lastLang.isEmpty() && (this->lastLang != lang))

    { 

        // Language has changed since last time

        // Remove previous translator, if any

        removeTranslator();

    }

    textFile = makeFileName(textFile);

    bool res=false;

    if (this->translator.isEmpty())

    {

        // Construct the full name of the localized resource

        XQSERVICE_DEBUG_PRINT("textFile name is %s", qPrintable(textFile));

        res = this->translator.load(textFile);

        if (res)

        {

            qApp->installTranslator(&this->translator);

            this->lastLang = lang;  // Remember the current language

            XQSERVICE_DEBUG_PRINT("Translator installed %s", qPrintable(lang));

        }

    }

    return res;

}

void XQAiwServiceDriver::removeTranslator()

{

    if (qApp && !this->translator.isEmpty())

    {

        qApp->removeTranslator(&this->translator);

    }

}

QString XQAiwServiceDriver::makeFileName(const QString &textFile) const

{

    QFileInfo info(textFile);

    QString ret = textFile;

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::makeFileName %s", qPrintable(textFile));

    if (info.baseName() == info.filePath())

    {

        // No path, apply the default path

        // Drive is where app is loaded, like "C:" or "Z:"

        ret = qApp->applicationFilePath().left(2) + "/resource/qt/translations/" + textFile;

    }

    // Add current language

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

    ret += "_"; 

    ret += lang;

    XQSERVICE_DEBUG_PRINT("XQAiwServiceDriver::makeFileName ret=%s", qPrintable(ret));

    return ret;

}