/**
   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 "downloadmanager.h"
#include "backgrounddownloadmanager.h"
#include "download.h"
#include "backgrounddownload.h"
#include "downloadmanagerclient.h"
#include "downloadevent.h"
#include "downloadinfo.h"
#include <QHash>
#include <QCoreApplication>
#include <QNetworkReply>

class BackgroundDownloadManagerPrivate
{
    //declare public implementation
    DM_DECLARE_PUBLIC(BackgroundDownloadManager);
public:
    BackgroundDownloadManagerPrivate();
    ~BackgroundDownloadManagerPrivate();

    QList<Download*> m_downloads; // list of downloads
    QString m_clientName; // client name
    QObject *m_receiver; // event reciever
    DownloadManager* m_downloadMgr; // not owned
    DownloadManagerClient* m_downloadMgrClient; // owned
    DownloadInfo* m_dlInfo; // not owned
};

BackgroundDownloadManagerPrivate::BackgroundDownloadManagerPrivate()
{
    m_clientName = "";
    m_receiver = 0;
    m_downloadMgr = 0;
    m_downloadMgrClient = 0;
}

BackgroundDownloadManagerPrivate::~BackgroundDownloadManagerPrivate()
{
    if (m_downloadMgrClient) {
        delete m_downloadMgrClient;
        m_downloadMgrClient = 0;
    }
    m_downloadMgr = 0;
    m_downloads.clear();
}

BackgroundDownloadManager::BackgroundDownloadManager(DownloadManager* downloadMgr)
{
    DM_INITIALIZE(BackgroundDownloadManager);
    priv->m_downloadMgr = downloadMgr;
    if (downloadMgr) {
        priv->m_clientName = downloadMgr->getAttribute(DlMgrClientName).toString();
        priv->m_dlInfo = downloadMgr->downloadInfo();
    }
}

// destructor for the download manager
BackgroundDownloadManager::~BackgroundDownloadManager()
{
    DM_UNINITIALIZE(BackgroundDownloadManager);
}

// initialises all the downloads which belongs to last download manager session
void BackgroundDownloadManager::init()
{
    //load all downloads which were created in the last session
    return;
}

// returns new download
// url indicates download url
Download* BackgroundDownloadManager::createDownload(const QString& url, DownloadType type)
{
    if (url.isEmpty())
        return NULL;

    DM_PRIVATE(BackgroundDownloadManager);
    // connection to server will be established whrn DownloadManagerClient object is created
    // so we delay the constructon of this object till client calls some function
    if (!priv->m_downloadMgrClient)
        priv->m_downloadMgrClient = new DownloadManagerClient(priv->m_downloadMgr);
    // create downlaod at server
    int downloadId = priv->m_downloadMgrClient->createDownload(url, type);
    if (downloadId == INVALID_DL_ID)
        return NULL;
    Download* dl = new BackgroundDownload(priv->m_downloadMgr, url, downloadId);
    if (dl)
        priv->m_downloads.append(dl);
    return dl;
}

// creates the background download from the persistantly stored download info
Download* BackgroundDownloadManager::createDownload(int id)
{
    DM_PRIVATE(BackgroundDownloadManager);

    if ((id == INVALID_DL_ID) || (!priv->m_dlInfo))
        return NULL;

    // connection to server will be established when DownloadManagerClient object is created
    // so we delay the constructon of this object till client calls some function
    if (!priv->m_downloadMgrClient)
        priv->m_downloadMgrClient = new DownloadManagerClient(priv->m_downloadMgr);
    QString url;
    priv->m_dlInfo->getValue(id, DownloadInfo::EUrl, url);
    // create downlaod at server
    bool status = priv->m_downloadMgrClient->attachToDownload(id);
    if (status == false) {
        // this means, download no more exists in server side
        priv->m_dlInfo->remove(id);
        return NULL;
    }
    Download* dl = new BackgroundDownload(priv->m_downloadMgr, url, id);
    if (dl)               
        priv->m_downloads.append(dl);
    return dl;
}

// sets the proxy
// proxyServer indicates proxy server name
// port indicates port number
void BackgroundDownloadManager::setProxy(const QString& proxyServer, int port)
{
    if (!proxyServer.isEmpty()) {
        DM_PRIVATE(BackgroundDownloadManager);
        // connection to server will be established whrn DownloadManagerClient object is created
    // so we delay the constructon of this object till client calls some function
        if (!priv->m_downloadMgrClient)
            priv->m_downloadMgrClient = new DownloadManagerClient(priv->m_downloadMgr);
        priv->m_downloadMgrClient->setProxy(proxyServer, port);
    }
}

// sets download manager attribute
// attr indicates download manager attribute
// value indicates value to be set
int BackgroundDownloadManager::setAttribute(DownloadManagerAttribute attr, const QVariant& value)
{
    // remove build warnings
    DM_PRIVATE(BackgroundDownloadManager);
    if (!priv->m_downloadMgrClient)
        return -1;
    int returnValue = priv->m_downloadMgrClient->setDownloadManagerAttribute(attr, value);
    return returnValue;
}

// fetches download manager attribute
// attr indicates download manager attribute whos value to be returned
QVariant BackgroundDownloadManager::getAttribute(DownloadManagerAttribute attr)
{
    DM_PRIVATE(BackgroundDownloadManager);
    if (!priv->m_downloadMgrClient)
        return QVariant();

    // if download manager error, return the last client-server error
    switch(attr) {
    case DlMgrServerError:
        return QVariant(priv->m_downloadMgrClient->serverError());
    default:
        break;
    }

    QVariant value = priv->m_downloadMgrClient->getDownloadManagerAttribute(attr);
    return value;
}

// returns all the current downloads
QList<Download*>& BackgroundDownloadManager::currentDownloads()
{
    DM_PRIVATE(BackgroundDownloadManager);
    return priv->m_downloads;
}

// finds a download provided id if exists
// id indicates identifier for download
Download* BackgroundDownloadManager::findDownload(int dlId)
{
    DM_PRIVATE(BackgroundDownloadManager);
    for (int i=0; i<priv->m_downloads.count(); ++i) {
        if (priv->m_downloads[i]->id() == dlId) {
            return priv->m_downloads[i];
        }
    }
    return 0;
}

// cancels all the downloads
void BackgroundDownloadManager::removeAll()
{
    DM_PRIVATE(BackgroundDownloadManager);
    if (!priv->m_downloadMgrClient)
        return;

    // before removing all downloads, remove their downloadinfo
    for (int i=0; i<priv->m_downloads.count(); ++i) {
        BackgroundDownload* download = dynamic_cast<BackgroundDownload*>(priv->m_downloads[i]);
        if (download)
            download->removeDownloadInfo();
    }

    priv->m_downloadMgrClient->removeAll();
    for (int i=0; i<priv->m_downloads.count(); ++i) {
        delete (priv->m_downloads[i]);
        priv->m_downloads[i] = 0;
    }
    priv->m_downloads.clear();
}

// cancels and removes the download
// dl indicates the download to be canceled and removed
void BackgroundDownloadManager::removeOne(Download* dl)
{
    // check if download exists
    if (!dl)
        return;

    DM_PRIVATE(BackgroundDownloadManager);
    // return if download manager client does not exist yet
    if (!priv->m_downloadMgrClient)
        return;
    // if this is a background download, remove it
    if (priv->m_downloads.contains(dl)) {
        priv->m_downloadMgrClient->removeDownload(dl->id());
        priv->m_downloads.removeOne(dl);
    }
}

// pauses all the downloads which are in progress
void BackgroundDownloadManager::pauseAll()
{
    DM_PRIVATE(BackgroundDownloadManager);
    if (priv->m_downloadMgrClient)
        priv->m_downloadMgrClient->pauseAll();
}

// resumes all the downloads which are paused
void BackgroundDownloadManager::resumeAll()
{
    DM_PRIVATE(BackgroundDownloadManager);
    if (priv->m_downloadMgrClient)
        priv->m_downloadMgrClient->resumeAll();
}

// get download manager client object
DownloadManagerClient* BackgroundDownloadManager::downloadManagerClient()
{
    DM_PRIVATE(BackgroundDownloadManager);
    return priv->m_downloadMgrClient;
}