/*
* 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 "xqservicelog.h"

#include <QApplication>
#include <QKeyEvent>
#include <QLabel>
#include <QVBoxLayout>
#include <QStackedWidget>
#include <QImageReader>
#include <QDebug>
#include <QTimer>
#include <QPushButton>
#include <QLineEdit>
#include <QListView>
#include <QMessageBox>
#include <xqsharablefile.h>

#include "serviceapp.h"
#include <xqserviceutil.h>

ServiceApp::ServiceApp(QWidget *parent, Qt::WFlags f)
    : QWidget(parent, f),
      mService(NULL),
      mUriService(NULL),
      mFileService(NULL)
{
    XQSERVICE_DEBUG_PRINT("ServiceApp::ServiceApp");
    if (XQServiceUtil::isService())
    {
        mService = new DialerService(this);
        mUriService = new UriService(this);
        mFileService = new FileService(this);
    }
    /* Adjust the palette */
#if defined(Q_WS_S60)
    QPalette p = qApp->palette();
    QColor color(192,192,192);
    QColor bg(201,250,250);
    p.setColor(QPalette::Highlight, color.lighter(200));
    p.setColor(QPalette::Text, Qt::black);
    p.setColor(QPalette::Base, bg);
    p.setColor(QPalette::WindowText, Qt::black);
    p.setColor(QPalette::Window, bg);
    p.setColor(QPalette::ButtonText, Qt::black);
    p.setColor(QPalette::Button, color.lighter(150));
    p.setColor(QPalette::Link, QColor(240,40,40));

    qApp->setPalette(p);
#endif

    QPushButton *quitButton = new QPushButton(tr("Quit"));
    QPushButton *answerButton = new QPushButton(tr("Async Answer"));
    connect(quitButton, SIGNAL(clicked()), this, SLOT(quit()));
    connect(answerButton, SIGNAL(clicked()), this, SLOT(answer()));

    /*
    mEndCallButton = new QPushButton(tr("End Call"));
    mEndCallButton->setEnabled(false);
    connect(mEndCallButton, SIGNAL(clicked()), this, SLOT(endCall()));
    */
    bool isService = XQServiceUtil::isService();
    
    QString t = "SERVICEAPP:\n";
    t = t + (isService ?  "    LAUNCHED AS SERVICE\n" : "    LAUNCHED NORMALLY\n");
    t = t + (XQServiceUtil::isEmbedded() ? "    EMBEDDED\n" : "    NOT EMBEDDED\n");
    
    QStringList args = QApplication::arguments();
    foreach (QString arg, args)
    {
        t += "cmdline arg=" + arg + "\n";
    }
    
    QLabel *title = new QLabel(t);

    mLabel = new QLabel("");
    mNumber = new QLineEdit("");
    
    QVBoxLayout *vl = new QVBoxLayout;
    vl->setMargin(0);
    vl->setSpacing(0);

    vl->addWidget(answerButton);
    vl->addWidget(quitButton);
    vl->addWidget(title);
    vl->addWidget(mLabel);
    vl->addWidget(mNumber);

    setLayout(vl);
   
#if defined(Q_WS_X11) || defined(Q_WS_WIN)
    setFixedSize(QSize(360,640)); // nHD
#elif defined(Q_WS_S60)
    // showMaximized();
    showFullScreen();
#endif
//    new DialerService(this);
}


ServiceApp::~ServiceApp()
{
    XQSERVICE_DEBUG_PRINT("ServiceApp::~ServiceApp");
    delete mService;
    delete mUriService;
    delete mFileService;
}

void ServiceApp::quit()
{
    XQSERVICE_DEBUG_PRINT("ServiceApp::quit");
    qApp->quit();
}

void ServiceApp::answer()
{
    XQSERVICE_DEBUG_PRINT("ServiceApp::answer");
    if (mService && mService->asyncAnswer())
    {
        // connect(mService, SIGNAL(returnValueDelivered()), this, SLOT(handleAnswerDelivered()));
        mService->complete(mNumber->text());
    }
    if (mUriService && mUriService->asyncAnswer())
    {
        connect(mUriService, SIGNAL(returnValueDelivered()), this, SLOT(handleAnswerDelivered()));
        mUriService->complete(true);
    }
    if (mFileService && mFileService->asyncAnswer())
    {
        connect(mUriService, SIGNAL(returnValueDelivered()), this, SLOT(handleAnswerDelivered()));
        mUriService->complete(true);
    }
}

void ServiceApp::handleAnswerDelivered()
{
    XQSERVICE_DEBUG_PRINT("ServiceApp::handleAnswerDelivered");
    quit();
    
}


void ServiceApp::endCall()
{
    XQSERVICE_DEBUG_PRINT("ServiceApp::endCall");
    //QVBoxLayout *vl = qobject_cast<QVBoxLayout *>(layout()) ;
    //vl->removeWidget(mEndCallButton);

    //XQServiceUtil::toBackground(true);
}

void ServiceApp::setLabelNumber(QString label,QString number)
{
    XQSERVICE_DEBUG_PRINT("ServiceApp::setLabelNumber");
    mLabel->setText(label);
    mNumber->setText(number);
}

// ----------DialerService---------------

DialerService::DialerService(ServiceApp* parent)
: XQServiceProvider(QLatin1String("com.nokia.services.serviceapp.Dialer"),parent),
    mServiceApp(parent),
    mAsyncReqId(-1),
    mAsyncAnswer(false)
{
    XQSERVICE_DEBUG_PRINT("DialerService::DialerService");
    publishAll();
    connect(this, SIGNAL(returnValueDelivered()), parent, SLOT(handleAnswerDelivered()));
}

DialerService::~DialerService()
{
    XQSERVICE_DEBUG_PRINT("DialerService::~DialerService");
}

void DialerService::complete(QString number)
{
    if (mAsyncReqId == -1)
        return;
    XQSERVICE_DEBUG_PRINT("DialerService::complete");
    completeRequest(mAsyncReqId,number.toInt());
}

int DialerService::dial(const QString& number, bool asyncAnswer)
{
    XQSERVICE_DEBUG_PRINT("DialerService::dial: %s,%d", qPrintable(number), asyncAnswer);
    XQRequestInfo info = requestInfo();
    
    XQSERVICE_DEBUG_PRINT("\tRequest info: sid=%X,vid=%X", info.clientSecureId(), info.clientVendorId());
    QSet<int> caps = info.clientCapabilities();
    QSetIterator<int> i(caps);
    while (i.hasNext())
        qDebug() << "Has capability " << i.next();    
    XQSERVICE_DEBUG_PRINT("\tRequest info: embed=%d,sync=%d", info.isEmbedded(), info.isSynchronous());
    
    QString label = "Dialer::dial:\n";
    label += QString("number=%1\n").arg(number);
    label += QString("asyncAnswer=%1\n").arg(asyncAnswer);
    
    mAsyncAnswer = asyncAnswer; 
    mNumber = number ;
    mServiceApp->setLabelNumber(label, number);
    int ret = 0;
    if (mAsyncAnswer)
    {
        mAsyncReqId = setCurrentRequestAsync();
        connect(this, SIGNAL(clientDisconnected()), this, SLOT(handleClientDisconnect()));
    }
    else
    {
        ret = number.toInt();
    }
    return ret;
}

void DialerService::handleClientDisconnect()
{
    XQSERVICE_DEBUG_PRINT("DialerService::handleClientDisconnect");
    // Just quit service application if client ends
    mAsyncAnswer = false;
    mServiceApp->quit();
}


// ----------UriService---------------

UriService::UriService(ServiceApp* parent)
: XQServiceProvider(QLatin1String("com.nokia.services.serviceapp.com.nokia.symbian.IUriView"),parent),
    mServiceApp(parent),
    mAsyncReqId(-1),
    mAsyncAnswer(false)
    
{
    XQSERVICE_DEBUG_PRINT("UriService::UriService");
    publishAll();
}

UriService::~UriService()
{
    XQSERVICE_DEBUG_PRINT("UriService::~UriService");
}

void UriService::complete(bool ok)
{
    if (mAsyncReqId == -1)
        return;
    XQSERVICE_DEBUG_PRINT("UriService::complete");
    completeRequest(mAsyncReqId, QVariant(mRetValue));
}

bool UriService::view(const QString& uri)
{
    XQSERVICE_DEBUG_PRINT("UriService::view(1)");
    return view(uri, true);
}

bool UriService::view(const QString& uri, bool retValue)
{
    XQSERVICE_DEBUG_PRINT("UriService::view(2)");
    QString label = "IUri::view\n:";
    label += QString ("Uri=%1\n").arg(uri);
    label += QString ("retValue=%1\n").arg(retValue);
    QString param = QString ("retValue=%1\n").arg(retValue);

    mAsyncAnswer = !XQServiceUtil::isEmbedded();;
    mRetValue = retValue;
    mServiceApp->setLabelNumber(label,param);
    if (mAsyncAnswer)
    {
        mAsyncReqId = setCurrentRequestAsync();
        connect(this, SIGNAL(clientDisconnected()), this, SLOT(handleClientDisconnect()));
    }
    
    return retValue;
}

void UriService::handleClientDisconnect()
{
    XQSERVICE_DEBUG_PRINT("UriService::handleClientDisconnect");

    // Just quit application
    mAsyncAnswer = false;
    mServiceApp->quit();
}


// ----------FileService---------------

FileService::FileService(ServiceApp* parent)
: XQServiceProvider(QLatin1String("com.nokia.services.serviceapp.com.nokia.symbian.IFileView"),parent),
    mServiceApp(parent),
    mAsyncReqId(-1),
    mAsyncAnswer(false)

{
    XQSERVICE_DEBUG_PRINT("FileService::FileService");
    publishAll();
}

FileService::~FileService()
{
    XQSERVICE_DEBUG_PRINT("FileService::~FileService");
}

void FileService::complete(bool ok)
{
    if (mAsyncReqId == -1)
        return;
    XQSERVICE_DEBUG_PRINT("FileService::complete");
    completeRequest(mAsyncReqId, QVariant(ok));
}

bool FileService::view(QString file)
{
    XQSERVICE_DEBUG_PRINT("FileService::view(QString)");
    QString label = "IFile::view\n:";
    QString param = QString ("File=%1\n").arg(file);

    mAsyncAnswer = !XQServiceUtil::isEmbedded();;
    mServiceApp->setLabelNumber(label,param);
    if (mAsyncAnswer)
    {
        mAsyncReqId = setCurrentRequestAsync();
        connect(this, SIGNAL(clientDisconnected()), this, SLOT(handleClientDisconnect()));
    }
    
    return true;
}


bool FileService::view(XQSharableFile sf)
{
    XQSERVICE_DEBUG_PRINT("FileService::view(XQSharebleFile)");
    QString label = "IFile::view\n:";
    QString param = QString ("File=%1\n").arg(sf.fileName());

    RFile file;
    bool ok = sf.getHandle( file );
    if (ok)
    {
        HBufC8* data = HBufC8::NewL(100);
        TPtr8 ptr = data->Des();
        TInt err  = file.Read( ptr );
        QString text = QString::fromUtf8((const char *)(data->Ptr()), data->Length());
        XQSERVICE_DEBUG_PRINT("FileService::file read,%d,%s", err, qPrintable(text));
        sf.close();
        delete data;
    }

    mAsyncAnswer = !XQServiceUtil::isEmbedded();;
    mServiceApp->setLabelNumber(label,param);
    if (mAsyncAnswer)
    {
        mAsyncReqId = setCurrentRequestAsync();
        connect(this, SIGNAL(clientDisconnected()), this, SLOT(handleClientDisconnect()));
    }
    return true;
}


void FileService::handleClientDisconnect()
{
    XQSERVICE_DEBUG_PRINT("FileService::handleClientDisconnect");

    // Just quit application
    mAsyncAnswer = false;
    mServiceApp->quit();
}