/**

   This file is part of CWRT package **

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

   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/>.

*/

#include "downloadmanagerclient.h"

#include "backgrounddownloadmanager.h"

#include "backgrounddownload.h"

#include <serviceipc.h>

#include <QTimer>

#include <QtNetwork>

class DownloadManagerClientPrivate

{

    DM_DECLARE_PUBLIC(DownloadManagerClient);

public:

    DownloadManagerClientPrivate();

    ~DownloadManagerClientPrivate();

    QString m_clientName;

    bool m_isConnected;

    int m_error;

    WRT::ServiceFwIPC* m_session;

    DownloadManager* m_downloadManager;

    QTimer* m_timer;

};

DownloadManagerClientPrivate::DownloadManagerClientPrivate()

{

    m_clientName = "";

    m_isConnected = false;

    m_error = 0;

    m_session = 0;

    m_downloadManager = 0;

    m_timer = 0;

}

DownloadManagerClientPrivate::~DownloadManagerClientPrivate()

{

    if (m_timer) {

        if (m_timer->isActive())

            m_timer->stop();

        delete m_timer;

        m_timer = 0;

    }

    if (m_session) {

        m_session->disconnect();

        delete m_session;

        m_session = 0;

    }

}

DownloadManagerClient::DownloadManagerClient(DownloadManager* downloadManager)

{

    DM_INITIALIZE(DownloadManagerClient);

    priv->m_downloadManager = downloadManager;

    priv->m_timer = new QTimer;

    priv->m_clientName = downloadManager->getAttribute(DlMgrClientName).toString();

    priv->m_session = new WRT::ServiceFwIPC(this);

    connect(priv->m_session, SIGNAL(error(int aError)), this, SLOT(setServerError(int error)));

    connect(priv->m_timer, SIGNAL(timeout()), this, SLOT(getEvents()));

    // establish communication with server

    initServer();

}

DownloadManagerClient::~DownloadManagerClient()

{

    DM_UNINITIALIZE(DownloadManagerClient);

}

bool DownloadManagerClient::initServer()

{

    DM_PRIVATE(DownloadManagerClient);

    // start server (if required) and connect to it

    connectToServer();

    if (priv->m_isConnected) {

        // set startup details - proxy, download path, progress mode

        // and attach to downloads

        setStartupInfo();

        // start timer to get events from server

        priv->m_timer->start(EVENTS_REQUEST_INTERVAL);

        priv->m_downloadManager->postEvent(ConnectedToServer, NULL);

    }

    return priv->m_isConnected;

}

bool DownloadManagerClient::connectToServer()

{

    DM_PRIVATE(DownloadManagerClient);

    if (priv->m_session) {

        int retry(2);

        for (;;)

        {

            priv->m_isConnected = priv->m_session->connect(DMSERVER);

            if (priv->m_isConnected) {

                break;

            }

            else {

                if (!priv->m_session->startServer(DMSERVER, DMSERVEREXE)) {

                    // start server failed.

                    break;

                }

            }

            if (0==--retry) {

                break;

            }

        }

    }

    if (!priv->m_isConnected) {

        delete priv->m_session;

        priv->m_session = 0;

    }

    return priv->m_isConnected;

}

void DownloadManagerClient::setStartupInfo()

{

    DM_PRIVATE(DownloadManagerClient);

    if (!priv->m_isConnected)

        return;

    if (priv->m_downloadManager) {

        // get data from download manager

        QNetworkProxy* proxy = priv->m_downloadManager->proxy();

        QString dlPath = priv->m_downloadManager->getAttribute(DlMgrDestPath).toString();

        int progressMode = priv->m_downloadManager->getAttribute(DlMgrProgressMode).toInt();

        int persistantMode = priv->m_downloadManager->getAttribute(DlMgrPersistantMode).toInt();

        QString data;

        // client name

        data.append(encodeString(priv->m_clientName));

        // proxy info

        if (proxy) {

            data.append(DM_MSG_DELIMITER);

            data.append(QString::number(SetProxy));

            data.append(DM_FIELD_DELIMITER);

            data.append(encodeString(proxy->hostName()));

            data.append(DM_FIELD_DELIMITER);

            data.append(QString::number(proxy->port()));

        }

        // download path

        data.append(DM_MSG_DELIMITER);

        data.append(QString::number(SetDownloadManagerAttribute));

        data.append(DM_FIELD_DELIMITER);

        data.append(QString::number(DlMgrDestPath));

        data.append(DM_FIELD_DELIMITER);

        data.append(encodeString(dlPath));

        // progress mode (quiet/non-quiet)

        data.append(DM_MSG_DELIMITER);

        data.append(QString::number(SetDownloadManagerAttribute));

        data.append(DM_FIELD_DELIMITER);

        data.append(QString::number(DlMgrProgressMode));

        data.append(DM_FIELD_DELIMITER);

        data.append(encodeString(QString::number(progressMode)));

        // persistant mode (active / inactive)

        data.append(DM_MSG_DELIMITER);

        data.append(QString::number(SetDownloadManagerAttribute));

        data.append(DM_FIELD_DELIMITER);

        data.append(QString::number(DlMgrPersistantMode));

        data.append(DM_FIELD_DELIMITER);

        data.append(encodeString(QString::number(persistantMode)));

        // send to sever

        if (priv->m_session->sendSync(QString::number(StartupInfo), data.toAscii()))

            priv->m_session->readAll();

    }

}

void DownloadManagerClient::setProxy(const QString& proxyServer, const int port)

{

    DM_PRIVATE(DownloadManagerClient);

    if (!priv->m_isConnected) {

        if (!initServer())

            return;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(encodeString(proxyServer));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(port));

    // send to sever

    if (priv->m_session->sendSync(QString::number(SetProxy), data.toAscii()))

        priv->m_session->readAll();

    else

        setServerError(WRT::ServiceFwIPC::EIPCError);

}

int DownloadManagerClient::createDownload(const QString& url, DownloadType type)

{

    DM_PRIVATE(DownloadManagerClient);

    int downloadId(INVALID_DL_ID);

    if (!priv->m_isConnected) {

        if (!initServer())

            return downloadId;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(encodeString(url));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(type));

    // send to sever

    if (priv->m_session->sendSync(QString::number(CreateDownload), data.toAscii())) {

        // expected response is

        // list[0] -> downloadId

        QByteArray bytes = priv->m_session->readAll();

        QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

        if (list.count() == 1)

            downloadId = list[0].toInt();

    }

    else {

        setServerError(WRT::ServiceFwIPC::EIPCError);

    }

    return downloadId;

}

bool DownloadManagerClient::attachToDownload(int dlId)

{

    DM_PRIVATE(DownloadManagerClient);

    bool status(false);

    if (!priv->m_isConnected) {

        if (!initServer())

            return status;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(dlId));

    // send to sever

    if (priv->m_session->sendSync(QString::number(AttachToDownload), data.toAscii())) {

        // expected response is

	// list[1] -> status

        QByteArray bytes = priv->m_session->readAll();

        QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

        if (list.count() == 1) {

            status = list[0].toInt();

	}

    }

    else {

        setServerError(WRT::ServiceFwIPC::EIPCError);

    }

    return status;

}

void DownloadManagerClient::removeDownload(int downloadId)

{

    DM_PRIVATE(DownloadManagerClient);

    if (!priv->m_isConnected) {

        if (!initServer())

            return;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(downloadId));

    // send to sever

    if (priv->m_session->sendSync(QString::number(RemoveDownload), data.toAscii()))

        priv->m_session->readAll();

    else

        setServerError(WRT::ServiceFwIPC::EIPCError);

}

void DownloadManagerClient::pauseAll()

{

    DM_PRIVATE(DownloadManagerClient);

    if (!priv->m_isConnected) {

        if (!initServer())

            return;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    // send to sever

    if (priv->m_session->sendSync(QString::number(PauseAll), data.toAscii()))

        priv->m_session->readAll();

    else

        setServerError(WRT::ServiceFwIPC::EIPCError);

}

void DownloadManagerClient::resumeAll()

{

    DM_PRIVATE(DownloadManagerClient);

    if (!priv->m_isConnected) {

        if (!initServer())

            return;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    // send to sever

    if (priv->m_session->sendSync(QString::number(ResumeAll), data.toAscii()))

        priv->m_session->readAll();

    else

        setServerError(WRT::ServiceFwIPC::EIPCError);

}

void DownloadManagerClient::removeAll()

{

    DM_PRIVATE(DownloadManagerClient);

    if (!priv->m_isConnected) {

        if (!initServer())

            return;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    // send to sever

    if (priv->m_session->sendSync(QString::number(RemoveAll), data.toAscii()))

        priv->m_session->readAll();

    else

        setServerError(WRT::ServiceFwIPC::EIPCError);

}

QVariant DownloadManagerClient::getDownloadManagerAttribute(DownloadManagerAttribute attr)

{

    DM_PRIVATE(DownloadManagerClient);

    QVariant returnValue;

    if (!priv->m_isConnected) {

        if (!initServer())

            return returnValue;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(attr));

    // send to sever

    if (priv->m_session->sendSync(QString::number(GetDownloadManagerAttribute), data.toAscii())) {

        // expected response is

        // list[0] -> attribute

        // list[1] -> value

        QByteArray bytes = priv->m_session->readAll();

        QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

        if (list.count() == 2) {

            if (list[0] == QString::number(attr))

                returnValue = QVariant(list[1]);

        }

    }

    else {

        setServerError(WRT::ServiceFwIPC::EIPCError);

    }

    return returnValue;

}

int DownloadManagerClient::setDownloadManagerAttribute(DownloadManagerAttribute attr, const QVariant& value)

{

    DM_PRIVATE(DownloadManagerClient);

    int returnValue(-1);

    if (!priv->m_isConnected) {

        if (!initServer())

            return returnValue;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(attr));

    data.append(DM_FIELD_DELIMITER);

    data.append(encodeString(value.toString()));

    // send to sever

    if (priv->m_session->sendSync(QString::number(SetDownloadManagerAttribute), data.toAscii())) {

        // expected response is

        // list[0] -> attribute

        // list[1] -> returnValue

        QByteArray bytes = priv->m_session->readAll();

        QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

        if (list.count() == 2) {

            if (list[0] == QString::number(attr))

                returnValue = list[1].toInt();

        }

    }

    else {

        setServerError(WRT::ServiceFwIPC::EIPCError);

    }

    return returnValue;

}

int DownloadManagerClient::startDownload(int dlId)

{

    DM_PRIVATE(DownloadManagerClient);

    int returnValue(-1);

    if (!priv->m_isConnected) {

        if (!initServer())

            return returnValue;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(dlId));

    // send to sever

    if (priv->m_session->sendSync(QString::number(StartDownload), data.toAscii())) {

        // expected response is

        // list[0] -> downloadId

        // list[1] -> returnValue

        QByteArray bytes = priv->m_session->readAll();

        QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

        if (list.count() == 2) {

            if (list[0] == QString::number(dlId))

                returnValue = list[1].toInt();

        }

    }

    else {

        setServerError(WRT::ServiceFwIPC::EIPCError);

    }

    return returnValue;

}

int DownloadManagerClient::pauseDownload(int dlId)

{

    DM_PRIVATE(DownloadManagerClient);

    int returnValue(-1);

    if (!priv->m_isConnected) {

        if (!initServer())

            return returnValue;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(dlId));

    // send to sever

    if (priv->m_session->sendSync(QString::number(PauseDownload), data.toAscii())) {

        // expected response is

        // list[0] -> downloadId

        // list[1] -> returnValue

        QByteArray bytes = priv->m_session->readAll();

        QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

        if (list.count() == 2) {

            if (list[0] == QString::number(dlId))

                returnValue = list[1].toInt();

        }

    }

    else {

        setServerError(WRT::ServiceFwIPC::EIPCError);

    }

    return returnValue;

}

int DownloadManagerClient::resumeDownload(int dlId)

{

    DM_PRIVATE(DownloadManagerClient);

    int returnValue(-1);

    if (!priv->m_isConnected) {

        if (!initServer())

            return returnValue;

    }

    // create string to send

    QString data;

    data.append(encodeString(priv->m_clientName));

    data.append(DM_FIELD_DELIMITER);

    data.append(QString::number(dlId));

    // send to sever

    if (priv->m_session->sendSync(QString::number(ResumeDownload), data.toAscii())) {

        // expected response is

        // list[0] -> downloadId

        // list[1] -> returnValue

        QByteArray bytes = priv->m_session->readAll();

        QStringList list = QString(bytes).split(DM_FIELD_DELIMITER);

        if (list.count() == 2) {

            if (list[0] == QString::number(dlId))

                returnValue = list[1].toInt();

        }

    }

    else {

        setServerError(WRT::ServiceFwIPC::EIPCError);

    }

    return returnValue;

}

int DownloadManagerClient::cancelDownload(int dlId)

{

    DM_PRIVATE(DownloadManagerClient);

    int returnValue(-1);

    if (!priv->m_isConnected) {

        if (!initServer())

            return returnValue;

    }