/**

   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 "progressivedownloadserver.h"

#include "download.h"

#include "dmcommon.h"

#include "dmcommoninternal.h"

#include <QTcpSocket>

#include <QHostAddress>

#define SERVER_WAIT_INTERVAL 1000

// private implementation

class ProgressiveDownloadServerPrivate

{

    DM_DECLARE_PUBLIC(ProgressiveDownloadServer);

public:

    ProgressiveDownloadServerPrivate();

    ~ProgressiveDownloadServerPrivate();

    QTcpServer* m_serverSocket;

    QTcpSocket* m_clientConnection;

    Download* m_download;

    DownloadState m_previousDlState;

};

ProgressiveDownloadServerPrivate::ProgressiveDownloadServerPrivate()

{

    m_serverSocket = 0;

    m_clientConnection = 0;

    m_download = 0;

    m_previousDlState = DlNone;

}

ProgressiveDownloadServerPrivate::~ProgressiveDownloadServerPrivate()

{

    if (m_serverSocket) {

        delete m_serverSocket;

        m_serverSocket = 0;

    }

}

Q_DECL_EXPORT ProgressiveDownloadServer::ProgressiveDownloadServer(Download* download)

{

    DM_INITIALIZE(ProgressiveDownloadServer);

    priv->m_download = download;

    // create server socket

    priv->m_serverSocket = new QTcpServer(this);

    connect(priv->m_serverSocket, SIGNAL(newConnection()), this, SLOT(handleConnection()));

}

ProgressiveDownloadServer::~ProgressiveDownloadServer()

{

    stopServer();

    DM_UNINITIALIZE(ProgressiveDownloadServer);

}

// starts the server

Q_DECL_EXPORT int ProgressiveDownloadServer::startServer(void)

{

    DM_PRIVATE(ProgressiveDownloadServer);

    if (!priv->m_serverSocket->isListening()) {

        QHostAddress localHost(QHostAddress::LocalHost);

        if (!priv->m_serverSocket->listen(localHost))

            return -1;

    }

    return 0;

}

// stops the server

Q_DECL_EXPORT int ProgressiveDownloadServer::stopServer(void)

{

    DM_PRIVATE(ProgressiveDownloadServer);

    // unregister the event listener

    priv->m_download->unregisterEventReceiver(this);

    // send the server down signal

    if ((priv->m_clientConnection) && (priv->m_clientConnection->state() == QAbstractSocket::ConnectedState)) {

        QByteArray block;

        QDataStream out(&block, QIODevice::WriteOnly);

        out.setVersion(QDataStream::Qt_4_0);

        out << (quint16)ProgressiveDlServerDown;

        priv->m_clientConnection->write(block);

        priv->m_clientConnection->flush();

        // wait till the data is written

        if (priv->m_clientConnection->waitForBytesWritten(SERVER_WAIT_INTERVAL))

            return 0;

        else

            return -1;

    }

    if (priv->m_serverSocket->isListening())

        priv->m_serverSocket->close();

    return 0;

}

Q_DECL_EXPORT quint16 ProgressiveDownloadServer::serverPort(void)

{

    DM_PRIVATE(ProgressiveDownloadServer);

    if (priv->m_serverSocket)

        return priv->m_serverSocket->serverPort();

    else

        return 0;

}

// last error occurred

Q_DECL_EXPORT ProgressiveDlServerError ProgressiveDownloadServer::lastError(void)

{

    DM_PRIVATE(ProgressiveDownloadServer);

    return priv->m_serverSocket->serverError();

}

// last error occurred

Q_DECL_EXPORT QString ProgressiveDownloadServer::lastErrorString(void)

{

    DM_PRIVATE(ProgressiveDownloadServer);

    return priv->m_serverSocket->errorString();

}

void ProgressiveDownloadServer::handleConnection(void)

{

    DM_PRIVATE(ProgressiveDownloadServer);

    priv->m_clientConnection = priv->m_serverSocket->nextPendingConnection();

    connect(priv->m_clientConnection, SIGNAL(readyRead()),

            this, SLOT(handleRequest()));

    priv->m_download->registerEventReceiver(this);

    // right now only one client is supported

    priv->m_serverSocket->close();

}

void ProgressiveDownloadServer::handleRequest(void)

{

    // handles the request from client

    DM_PRIVATE(ProgressiveDownloadServer);

    quint16 requestCode;

    QDataStream in(priv->m_clientConnection);

    in.setVersion(QDataStream::Qt_4_0);

    if (priv->m_clientConnection->bytesAvailable() < (int)sizeof(quint16))

        return;

    in >> requestCode;

    // act according to the request

    if ((ProgressiveOperation)requestCode == DlPause)

        priv->m_download->pause();

    else if ((ProgressiveOperation)requestCode == DlResume)

        priv->m_download->resume();

    else if ((ProgressiveOperation)requestCode == DlCancel)

        priv->m_download->cancel();

    else if ((ProgressiveOperation)requestCode == DlGetAttribute) {

        // getAttribute is synchronous, so send the response here

        quint16 attr;

        in >> attr;

        QVariant value;

        value = priv->m_download->getAttribute((DownloadAttribute)attr);

        QByteArray block;

        QDataStream out(&block, QIODevice::WriteOnly);

        out.setVersion(QDataStream::Qt_4_0);

        out << (quint16)ProgressiveDlGetAttribute;

        out << value;

        priv->m_clientConnection->write(block);

        priv->m_clientConnection->flush();

    }

}

bool ProgressiveDownloadServer::event(QEvent *event)

{

    DM_PRIVATE(ProgressiveDownloadServer);

    DEventType type = (DEventType)event->type();

    QByteArray block;

    QDataStream out(&block, QIODevice::WriteOnly);

    out.setVersion(QDataStream::Qt_4_0);

    // handle the events from the download and send the response to the client

    switch(type) {

    case Progress:

        // send the response only once when it is resumed

        // to avoid continueously writing to the response buffer and increasing the ipc overhead 

        if (priv->m_previousDlState != DlInprogress) {

            priv->m_previousDlState = DlInprogress;

            out << (quint16)ProgressiveDlInprogress;

            priv->m_clientConnection->write(block);

            priv->m_clientConnection->flush();

        }

        break;

    case Paused:

        priv->m_previousDlState = DlPaused;

        out << (quint16)ProgressiveDlPaused;

        priv->m_clientConnection->write(block);

        priv->m_clientConnection->flush();

        break;

    case Completed:

        priv->m_previousDlState = DlCompleted;

        out << (quint16)ProgressiveDlCompleted;

        priv->m_clientConnection->write(block);

        priv->m_clientConnection->flush();

        break;

    case Failed:

        priv->m_previousDlState = DlFailed;

        out << (quint16)ProgressiveDlFailed;

        priv->m_clientConnection->write(block);

        priv->m_clientConnection->flush();

        break;

    case Cancelled:

        priv->m_previousDlState = DlCancelled;

        out << (quint16)ProgressiveDlCancelled;

        priv->m_clientConnection->write(block);

        priv->m_clientConnection->flush();

        break;

    case NetworkLoss:

        priv->m_previousDlState = DlPaused;

        out << (quint16)ProgressiveDlPaused;

        priv->m_clientConnection->write(block);

        priv->m_clientConnection->flush();

        break;

    default:

        break;

    }

    // event is consumed in any case.

    return true;

}