/**

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

#include "omaddparser.h"

#include "downloadmanager.h"

#include "clientdownload.h"

#include "downloadcore.h"

#include "downloadevent.h"

#include <QCoreApplication>

#include <QFileInfo>

#ifdef Q_OS_LINUX

  #include <sys/statvfs.h>

#endif

#ifdef Q_OS_LINUX 

static double freeSpace(const char *path)

#else

static double freeSpace(const char* /*path*/)

#endif

{

#ifdef Q_OS_LINUX   

    struct statvfs fiData;

    if ((statvfs(path,&fiData)) < 0 ) 

        return 0;

    else {

        int blockSize = fiData.f_bsize/1024;

        double freeSize = (fiData.f_bavail)*blockSize;

        freeSize = freeSize/1024;

        return freeSize;

    }

#endif

    return 0;

}

// private implementation

class OMADownloadBackendPrivate {

    DM_DECLARE_PUBLIC(OMADownloadBackend);

public:

    OMADownloadBackendPrivate();

    ~OMADownloadBackendPrivate();

    DownloadCore *m_downloadCore;

    ClientDownload *m_download;

    OMADownloadDescParser *m_parser; // for parsing oma descriptor

    OMADownloadDescriptor *m_downloadDesc;

    bool m_isMediaDownload; // flag to indicate if media download is happening

    ClientDownload *m_mediaDownload; // not owned

    bool m_isUserCancelled;

};

OMADownloadBackendPrivate::OMADownloadBackendPrivate()

{

    m_downloadCore = 0;

    m_download = 0;

    m_parser = 0;

    m_downloadDesc = 0;

    m_isMediaDownload = false;

    m_mediaDownload = 0;

    m_isUserCancelled = false;

}

OMADownloadBackendPrivate::~OMADownloadBackendPrivate()

{

    if (m_parser) {

        delete m_parser;

        m_parser = 0;

        m_downloadDesc = 0;

    }

    if (m_mediaDownload) {

        delete m_mediaDownload;

        m_mediaDownload = NULL;

    }

}

OMADownloadBackend::OMADownloadBackend(DownloadCore *dlCore, ClientDownload *dl)

    :DownloadBackend(dlCore, dl)

{

    DM_INITIALIZE(OMADownloadBackend);

    priv->m_downloadCore = dlCore;

    priv->m_download = dl;

}

OMADownloadBackend::~OMADownloadBackend()

{

     DM_UNINITIALIZE(OMADownloadBackend);

}

int OMADownloadBackend::pause()

{

    DM_PRIVATE(OMADownloadBackend);

    if (priv->m_isMediaDownload) {

        priv->m_mediaDownload->pause();

        setDownloadState(DlPaused);

    }

    return 0;

}

int OMADownloadBackend::resume()

{

    DM_PRIVATE(OMADownloadBackend);

    priv->m_isUserCancelled = false;

    if (priv->m_isMediaDownload)

        return (priv->m_mediaDownload->resume());

    // Ready to download after the descriptor is parsed

    // capability check on the descriptor information

    if (checkDownloadDescriptor()) {

         // create download for media object

        priv->m_mediaDownload = new ClientDownload(priv->m_download->downloadManager(), 

                priv->m_downloadDesc->getAttribute(OMADownloadDescObjectURI).toString(), priv->m_download->id()); 

        if (!priv->m_mediaDownload) {

            deleteInfo(); 

            return -1;               

        }

        priv->m_mediaDownload->setAttribute(DlFileName, priv->m_downloadDesc->getAttribute(OMADownloadDescName));

        priv->m_mediaDownload->registerEventReceiver(this);

        priv->m_mediaDownload->start();

        priv->m_isMediaDownload = true; 

        deleteInfo(); 

        return 0;         

    }

    return -1;

}

int OMADownloadBackend::cancel()

{

    DM_PRIVATE(OMADownloadBackend);

    priv->m_isUserCancelled = true;

    if (priv->m_isMediaDownload)

        priv->m_mediaDownload->cancel();

    else

        DownloadBackend::cancel();

    return 0;

}

QVariant OMADownloadBackend::getAttribute(DownloadAttribute attr)

{

    DM_PRIVATE(OMADownloadBackend);

    switch(attr) {

    case OMADownloadDescriptorName:

        return priv->m_downloadDesc->getAttribute(OMADownloadDescName);

    case OMADownloadDescriptorVersion:

        return priv->m_downloadDesc->getAttribute(OMADownloadDescVersion);

    case OMADownloadDescriptorType:

        return priv->m_downloadDesc->getAttribute(OMADownloadDescType);

    case OMADownloadDescriptorSize:

        return priv->m_downloadDesc->getAttribute(OMADownloadDescSize);

    case OMADownloadDescriptorVendor:

        return priv->m_downloadDesc->getAttribute(OMADownloadDescVendor);

    case OMADownloadDescriptorDescription:

        return priv->m_downloadDesc->getAttribute(OMADownloadDescDescription);

    case DlFileName:

    {

        if (!priv->m_isMediaDownload) {

            QString url = priv->m_downloadCore->url();

            QFileInfo fileUrl(url);

            return QVariant(fileUrl.fileName());

        } else

            return priv->m_downloadDesc->getAttribute(OMADownloadDescName);

    }

    case DlContentType:

    {

        if (!priv->m_isMediaDownload)

            return DownloadBackend::getAttribute(DlContentType);

        else

            return priv->m_mediaDownload->getAttribute(DlContentType);

    }

    default:

        return DownloadBackend::getAttribute(attr);

    }    

    return QVariant();

}

int OMADownloadBackend::setAttribute(DownloadAttribute attr, const QVariant& value)

{

    return DownloadBackend::setAttribute(attr, value);

}

// stores the data in storage

void OMADownloadBackend::store(QByteArray /*data*/, bool /*lastChunk=false*/)

{

    return;

}

// deletes the storage

void OMADownloadBackend::deleteStore()

{

    return;

}

// returns the size of stored data

qint64 OMADownloadBackend::storedDataSize()

{

    return 0;

}

void OMADownloadBackend::bytesRecieved(qint64 /*bytesRecieved*/, qint64 /*bytesTotal*/)

{

     //Do nothing. This is here to avoid this signal to reach to base class' slot.

     return;

}

void OMADownloadBackend::bytesUploaded(qint64 bytesUploaded, qint64 bytesTotal)

{

    DM_PRIVATE(OMADownloadBackend); 

    // once data is uploaded, cancel the transaction

    if (bytesUploaded == bytesTotal)

        priv->m_downloadCore->abort() ;

}

void OMADownloadBackend::handleFinished()

{

     DM_PRIVATE(OMADownloadBackend);

     QString contentType = priv->m_downloadCore->contentType();

     if (contentType == OMA_CONTENT_TYPE) {

         bool bSucceeded = parseDownloadDescriptor();

         if (bSucceeded) {

             priv->m_downloadDesc = priv->m_parser->downloadDescriptor();

             QString objectURI = priv->m_downloadDesc->getAttribute(OMADownloadDescObjectURI).toString();

             if (objectURI.isEmpty()) {

                 priv->m_downloadCore->post(priv->m_downloadDesc->getAttribute(OMADownloadDescInstallNotifyURI).toString(), QByteArray("905 Attribute Mismatch"));

                 priv->m_downloadCore->setLastError(QNetworkReply::UnknownContentError);

                 priv->m_downloadCore->setLastErrorString(tr("No ObjectURI"));

                 setDownloadState(DlFailed);

                 postEvent(Error, NULL);

                 return;

             }

             setDownloadState(DlPaused);

             postEvent(OMADownloadDescriptorReady, NULL);

         } else {

             priv->m_downloadDesc = priv->m_parser->downloadDescriptor();

             priv->m_downloadCore->post(priv->m_downloadDesc->getAttribute(OMADownloadDescInstallNotifyURI).toString(), QByteArray("906 Invalid descriptor"));

             priv->m_downloadCore->setLastError(QNetworkReply::UnknownContentError);

             priv->m_downloadCore->setLastErrorString(tr("Invalid Descriptor"));

             setDownloadState(DlFailed);

             postEvent(Error, NULL);

         }

     }

}

bool OMADownloadBackend::parseDownloadDescriptor()

{

    DM_PRIVATE(OMADownloadBackend);

    priv->m_parser = new OMADownloadDescParser();

    QXmlInputSource source(priv->m_downloadCore->reply());

    QXmlSimpleReader reader;

    reader.setContentHandler(priv->m_parser);

    reader.setErrorHandler(priv->m_parser);

    return reader.parse(source);

}

// capability check on the descriptor

bool OMADownloadBackend::checkDownloadDescriptor()

{

    DM_PRIVATE(OMADownloadBackend);

    QString version = priv->m_downloadDesc->getAttribute(OMADownloadDescVersion).toString();

    if (! version.isEmpty() && (version != OMA_VERSION_1)) {

        priv->m_downloadCore->post(priv->m_downloadDesc->getAttribute(OMADownloadDescInstallNotifyURI).toString(), QByteArray("951 Invalid DDVersion"));

        priv->m_downloadCore->setLastError(QNetworkReply::UnknownContentError);

        priv->m_downloadCore->setLastErrorString(tr("951 Invalid DDVersion"));

        setDownloadState(DlFailed); 

        postEvent(Error, NULL);

        return false; 

    } 

#ifdef Q_OS_LINUX

    // "Size" check needs to be done

    double fileSize =  priv->m_downloadDesc->getAttribute(OMADownloadDescSize).toDouble();

    double mbFactor = 1024*1024;

    fileSize = fileSize/mbFactor; //fileSize in MB

    double spaceLeft = freeSpace(ROOT_PATH); //spaze left in MB

    if (fileSize > spaceLeft) {

        priv->m_downloadCore->post(priv->m_downloadDesc->getAttribute(OMADownloadDescInstallNotifyURI).toString(), QByteArray("901 Insufficient memory"));

        priv->m_downloadCore->setLastError(QNetworkReply::UnknownContentError);

        priv->m_downloadCore->setLastErrorString(tr("901 Insufficient Memory"));

        setDownloadState(DlFailed);

        postEvent(Error, NULL);

        return false;       

    } 

#endif

    return true;

}

bool OMADownloadBackend::event(QEvent *event)

{

    DM_PRIVATE(OMADownloadBackend);

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

    switch(type) {

    case Started:

        break;

    case HeaderReceived:

    {

        // handling the events from media object downloads

        // Check the mismatch in total size returned by server with the size given in the descriptor.

        //This piece of code is commented as-of-now. when needed in future , will be uncommented

        /*int totalSize = dl->getAttribute(DlTotalSize).toInt();

        if (priv->m_downloadDesc->getAttribute(OMADownloadDescSize).toInt() != totalSize)

        {

            priv->m_downloadCore->post(priv->m_downloadDesc->getAttribute(OMADownloadDescInstallNotifyURI).toString(), QByteArray("905 Attribute Mismatch"));

            if (dl)

            {

                dl->setError("905 Attribute Mismatch");

                dl->cancel();

                dl->setDownloadState(DlFailed);

                dl->postEvent(Error, NULL);

            } 

            return true;

        }*/

        // Check the mismatch in content type returned by server with the content type given in the descriptor.

        QString contentType = priv->m_mediaDownload->getAttribute(DlContentType).toString();

        if (priv->m_downloadDesc->getAttribute(OMADownloadDescType).toString() != contentType) {

            // media object download cannot be proceeded

            if (priv->m_mediaDownload) {

                priv->m_mediaDownload->setError("905 Attribute Mismatch");

                priv->m_mediaDownload->cancel();

                priv->m_mediaDownload->setDownloadState(DlFailed);

                priv->m_mediaDownload->postEvent(Error, NULL);

            } 

            break;

        } 

    }

    case Progress:

    {

        QVariant tSize = priv->m_mediaDownload->getAttribute(DlTotalSize);

        setTotalSize(tSize.toInt());

        QVariant curDlsize = priv->m_mediaDownload->getAttribute(DlDownloadedSize);

        setDownloadedDataSize(curDlsize.toInt());

        setDownloadState(DlInprogress);

        postEvent(Progress, NULL);

        break;

    }

    case NetworkLoss:

    {

        postEvent(NetworkLoss, NULL);

        break;

    }

    case Cancelled:

    {

        if (priv->m_isUserCancelled)

            priv->m_downloadCore->post(priv->m_downloadDesc->getAttribute(OMADownloadDescInstallNotifyURI).toString(), QByteArray("902 User Cancelled"));

        setDownloadState(DlCancelled);

        postEvent(Cancelled, NULL);

        break;

    }

    case Completed:

    {

        priv->m_downloadCore->post(priv->m_downloadDesc->getAttribute(OMADownloadDescInstallNotifyURI).toString(), QByteArray("900 Success "));

        setDownloadState(DlCompleted);

        postEvent(Completed, NULL); 

        break;

    }

    case Error:

    {

        priv->m_downloadCore->post(priv->m_downloadDesc->getAttribute(OMADownloadDescInstallNotifyURI).toString(), QByteArray("905 Attribute Mismatch"));

        priv->m_downloadCore->setLastError(QNetworkReply::UnknownContentError);

        priv->m_downloadCore->setLastErrorString(tr("905 Attribute Mismatch"));

        setDownloadState(DlFailed);

        postEvent(Error, NULL);

        break;

    } 

    default:

        break;

    }

    return true;

}