/**

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

#include "clientdownload.h"

#include "downloadevent.h"

#include "downloadinfo.h"

#include "downloadcoremanager.h"

#include "backgrounddownloadmanager.h"

#include "paralleldownloadmanager.h"

#include "sequentialdownloadmanager.h"

#include <QNetworkReply>

#include <QNetworkProxy>

#include <QList>

#include <QDir>

#include <QCoreApplication>

// defualt download path

#define DOWNLOAD_PATH QDir::homePath() + QObject::tr("/Downloads")

class DownloadManagerPrivate

{

    //declare public implementation

    DM_DECLARE_PUBLIC(DownloadManager);

public:

    DownloadManagerPrivate();

    ~DownloadManagerPrivate();

    QString m_clientName; // client name

    QNetworkProxy *m_proxy;

    QObject *m_receiver; // event reciever

    DownloadInfo *m_dlInfo;

    DownloadCoreManager *m_dlCoreManager; // manages all the download cores

    QString m_destPath; // download destination path

    BackgroundDownloadManager* m_backgroundManager;

    ParallelDownloadManager *m_parallelManager; // manages parallel downloads

    SequentialDownloadManager *m_sequentialManager; // manages sequential downloads

    QList<Download*> m_totalDownloads; // has a list of both parallel and sequential downloads, but doesnt own it

    DownloadMgrProgressMode m_progressMode;

    DownloadMgrPersistantMode m_persistantMode;

};

DownloadManagerPrivate::DownloadManagerPrivate()

{

    m_clientName = "";

    m_proxy = 0;

    m_receiver = 0;

    m_dlInfo = 0;

    m_dlCoreManager = 0;

    // set the download destination path to default path

    m_destPath = DOWNLOAD_PATH;

    m_backgroundManager = 0;

    m_parallelManager = 0;

    m_sequentialManager = 0;

    m_progressMode = NonQuiet;

    m_persistantMode = Active;

}

DownloadManagerPrivate::~DownloadManagerPrivate()

{

    if(m_sequentialManager)

    {

        delete m_sequentialManager;

        m_sequentialManager = 0;

    }

    if(m_parallelManager)

    {

        delete m_parallelManager;

        m_parallelManager = 0;

    }

    if (m_backgroundManager)

    {

        delete m_backgroundManager;

        m_backgroundManager = 0;

    }

    if(m_proxy)

    {

        delete m_proxy;

        m_proxy = 0;

    }

    if(m_dlInfo)

    {

        m_dlInfo->update();

        delete m_dlInfo;

        m_dlInfo = 0;

    }

    if(m_dlCoreManager)

    {

        delete m_dlCoreManager;

        m_dlCoreManager = 0;

    }

}

/*!

 * \class DownloadManager

 *

 * \brief The public APIs for managing the downloads

 *

 * This class has the public APIs for managing the downloads

 */

/*!

  creates an instance of download manager

  \a clientName indicates the name of the client

*/

Q_DECL_EXPORT DownloadManager::DownloadManager(const QString& clientName)

{

    DM_INITIALIZE(DownloadManager);

    priv->m_clientName = clientName;

    //create a download info to save download informations

    priv->m_dlInfo = new DownloadInfo(clientName);

    // create download core manager

    priv->m_dlCoreManager = new DownloadCoreManager(clientName);

    // create background download manager

    priv->m_backgroundManager = new BackgroundDownloadManager(this);

    // create parallel download manager

    priv->m_parallelManager = new ParallelDownloadManager();

    // create sequential download manager

    priv->m_sequentialManager = new SequentialDownloadManager();

}

/*!

  destructor for the download manager

*/

Q_DECL_EXPORT DownloadManager::~DownloadManager()

{

    DM_UNINITIALIZE(DownloadManager);

}

/*!

  initialises all the downloads which belongs to last download manager session

*/

Q_DECL_EXPORT void DownloadManager::init()

{

    //load all downloads which were created in the last session

    loadAllDownloads();

}

/*!

  returns new download

  \a url indicates download url

  \a type indicates whether it is sequential or parallel download

*/

Q_DECL_EXPORT Download* DownloadManager::createDownload(const QString& url, DownloadType type/*=Parallel*/, DownloadScope scope/*=Normal*/)

{

    DM_PRIVATE(DownloadManager);

    if(url == "")

        return NULL;

    Download* dl(0);

    if (scope == Normal) {

        dl = new ClientDownload(this, url, generateDlId());

        if(type == Parallel)

            priv->m_parallelManager->addToParallelDownload(dl);

        else if(type == Sequential) {

            // by default the priority is low

            dl->setAttribute(DlPriority, (int)Low);

            priv->m_sequentialManager->addToSequentialDownload(dl);

        }

        postEvent(DownloadCreated, NULL);

    }

    else if (scope == Background) {

        dl = priv->m_backgroundManager->createDownload(url, type);

    }

    return dl;

}

/*!

  returns new download

  \a reply indicates network reply which is already initiated

*/

Q_DECL_EXPORT Download* DownloadManager::createDownload(QNetworkReply *reply)

{

    DM_PRIVATE(DownloadManager);

    if(!reply)

        return NULL;

    ClientDownload *dl = new ClientDownload(this, reply, generateDlId());

    priv->m_parallelManager->addToParallelDownload(dl);

    postEvent(DownloadCreated, NULL);

    return dl;

}

Download* DownloadManager::createDownload(int dlId, DownloadScope scope)

{

    DM_PRIVATE(DownloadManager);

    if(dlId == INVALID_DL_ID)

        return NULL;

    Download *dl = NULL;

    if (scope == Normal){

        dl = new ClientDownload(this, dlId);

        DownloadType type = (DownloadType)(dl->getAttribute(DlDownloadType).toInt());

        if(type == Parallel)

            priv->m_parallelManager->addToParallelDownload(dl);

        else

            priv->m_sequentialManager->addToSequentialDownload(dl);

    } else if (scope == Background){

        dl = priv->m_backgroundManager->createDownload(dlId);

    } else

        return NULL;

    if (dl)

         postEvent(DownloadCreated, NULL);

    return dl;

}

/*!

  sets the proxy

  \a proxyServer indicates proxy server name

  \a port indicates port number

*/

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

{

    DM_PRIVATE(DownloadManager);

    if(priv->m_proxy)

    {

        delete priv->m_proxy;

        priv->m_proxy = 0;

    }

    priv->m_proxy = new QNetworkProxy(QNetworkProxy::HttpCachingProxy, proxyServer, port );

    return;

}

/*!

  registers event listener

  \a reciever indicates reciever object to be registered for download events

*/

Q_DECL_EXPORT void DownloadManager::registerEventReceiver(QObject *receiver)

{

    DM_PRIVATE(DownloadManager);

    if (receiver)

        priv->m_receiver = receiver;

    return;

}

/*!

  unregister event listener

  \a reciever indicates reciever object to be unregistered

*/

Q_DECL_EXPORT void DownloadManager::unregisterEventReceiver(QObject *receiver)

{

    DM_PRIVATE(DownloadManager);

    if(receiver == priv->m_receiver)

    {

        priv->m_receiver = 0;

    }

    return;

}

/*!

  sets download manager attribute

  \a attr indicates download manager attribute

  \a value indicates value to be set

*/

Q_DECL_EXPORT int DownloadManager::setAttribute(DownloadManagerAttribute attr, const QVariant& value)

{

    DM_PRIVATE(DownloadManager);

    switch(attr)

    {

        case DlMgrDestPath:

        {

            priv->m_destPath = value.toString();

            return 0;

        }

        case DlMgrProgressMode:

        {

            priv->m_progressMode = (DownloadMgrProgressMode)value.toInt();

            return 0;

        }

        case DlMgrPersistantMode:

        {

            priv->m_persistantMode = (DownloadMgrPersistantMode)value.toInt();

            return 0;

        }

        default :

            return -1;

    }

    return -1;

}

/*!

  fetches download manager attribute

  \a attr indicates download manager attribute whos value to be returned

*/

Q_DECL_EXPORT QVariant DownloadManager::getAttribute(DownloadManagerAttribute attr)

{

    DM_PRIVATE(DownloadManager);

    switch(attr)

    {

        case DlMgrDlCount:

        {

            int count(0);

            if(priv->m_parallelManager)

                count += priv->m_parallelManager->currentDownloads().count();

            if(priv->m_sequentialManager)

                count += priv->m_sequentialManager->currentDownloads().count();

            if(priv->m_backgroundManager)

                count += priv->m_backgroundManager->currentDownloads().count();

            return QVariant(count);

        }

        case DlMgrClientName:

        {

            return QVariant(priv->m_clientName);

        }

        case DlMgrDestPath:

        {

            return QVariant(priv->m_destPath);

        }

        case DlMgrServerError:

        {

            // These cases apply only for Background Download Manager as this attribute

            // is for getting download manager client-server communication related errors

            QVariant value;

            if(priv->m_backgroundManager)

                value = priv->m_backgroundManager->getAttribute(attr);

            return value;

        }

        case DlMgrProgressMode:

        {

            return QVariant(priv->m_progressMode);

        }

        case DlMgrPersistantMode:

        {

            return QVariant(priv->m_persistantMode);

        }

        default :

            return QVariant();

    }

    return QVariant();

}

/*!

  returns all the current downloads

*/

Q_DECL_EXPORT QList<Download*>& DownloadManager::currentDownloads()

{

    DM_PRIVATE(DownloadManager);

    priv->m_totalDownloads.clear();

    if(priv->m_parallelManager) {

        for(int i = 0;i < priv->m_parallelManager->currentDownloads().size(); ++i)

            priv->m_totalDownloads.append(priv->m_parallelManager->currentDownloads()[i]);

    }

    if(priv->m_sequentialManager) {

        for(int i = 0;i < priv->m_sequentialManager->currentDownloads().size(); ++i)

            priv->m_totalDownloads.append(priv->m_sequentialManager->currentDownloads()[i]);

    }

    if(priv->m_backgroundManager) {

        for(int i = 0;i < priv->m_backgroundManager->currentDownloads().size(); ++i)

            priv->m_totalDownloads.append(priv->m_backgroundManager->currentDownloads()[i]);

    }

    return priv->m_totalDownloads;

}

/*!

  finds a download provided id if exists

  \a id indicates identifier for download

*/

Q_DECL_EXPORT Download* DownloadManager::findDownload(int dlId)

{

    DM_PRIVATE(DownloadManager);

    Download* dl = NULL;

    if(priv->m_parallelManager)

    {

        dl = priv->m_parallelManager->findDownload(dlId);

        if(dl)

            return dl;

    }

    if(priv->m_sequentialManager)

    {

        dl = priv->m_sequentialManager->findDownload(dlId);

        if(dl)

            return dl;

    }

    if(priv->m_backgroundManager)

    {

        dl = priv->m_backgroundManager->findDownload(dlId);

        if(dl)

            return dl;

    }

    return NULL;

}

/*!

  cancels all the downloads

*/

Q_DECL_EXPORT void DownloadManager::removeAll()

{

    DM_PRIVATE(DownloadManager);

    if(priv->m_parallelManager)

        priv->m_parallelManager->removeAll();

    if(priv->m_sequentialManager)

        priv->m_sequentialManager->removeAll();

    if(priv->m_backgroundManager)

        priv->m_backgroundManager->removeAll();

    postEvent(DownloadsCleared, NULL);

    return;

}

/*!

  cancels and removes the download

  \a dl indicates the download to be canceled and removed

*/

Q_DECL_EXPORT void DownloadManager::removeOne(Download *dl)

{

    if (!dl)

        return;

    DM_PRIVATE(DownloadManager);

    if(priv->m_parallelManager)

        priv->m_parallelManager->removeOne(dl);

    if(priv->m_sequentialManager)

        priv->m_sequentialManager->removeOne(dl);

    if(priv->m_backgroundManager)

        priv->m_backgroundManager->removeOne(dl);

    if((priv->m_parallelManager->currentDownloads().count() == 0) &&

        (priv->m_sequentialManager->currentDownloads().count() == 0) &&

        (priv->m_backgroundManager->currentDownloads().count() == 0))

        postEvent(DownloadsCleared, NULL);

    return;

}

/*!

  pauses all the downloads which are in progress

*/

Q_DECL_EXPORT void DownloadManager::pauseAll()

{

    DM_PRIVATE(DownloadManager);

    if(priv->m_parallelManager)

        priv->m_parallelManager->pauseAll();

    if(priv->m_sequentialManager)

        priv->m_sequentialManager->pauseAll();

    if(priv->m_backgroundManager)

        priv->m_backgroundManager->pauseAll();

    return;

}

/*!

  resumes all the downloads which are paused

*/

Q_DECL_EXPORT void DownloadManager::resumeAll()

{

    DM_PRIVATE(DownloadManager);

    if(priv->m_parallelManager)

        priv->m_parallelManager->resumeAll();

    if(priv->m_sequentialManager)

        priv->m_sequentialManager->resumeAll();

    if(priv->m_backgroundManager)

        priv->m_backgroundManager->resumeAll();

    return;

}

/*!

  returns the proxy used

*/

Q_DECL_EXPORT QNetworkProxy* DownloadManager::proxy()

{

    DM_PRIVATE(DownloadManager);

    return priv->m_proxy;

}

DownloadInfo* DownloadManager::downloadInfo()

{

    DM_PRIVATE(DownloadManager);

    return priv->m_dlInfo;

}

DownloadCoreManager* DownloadManager::downloadCoreManager()

{

    DM_PRIVATE(DownloadManager);

    return priv->m_dlCoreManager;

}

SequentialDownloadManager* DownloadManager::sequentialManager()

{

    DM_PRIVATE(DownloadManager);

    return priv->m_sequentialManager;

}

BackgroundDownloadManager* DownloadManager::backgroundManager()

{

    DM_PRIVATE(DownloadManager);

    return priv->m_backgroundManager;

}

void DownloadManager::loadAllDownloads()

{

    DM_PRIVATE(DownloadManager);

    // read the saved downloads information and create download

    QVector<int> ids = DownloadInfo::getAllDownloads(priv->m_clientName);

    for(int i=0; i<ids.size(); i++)

    {

        if(!findDownload(ids[i])) {

            long scope;

            priv->m_dlInfo->getValue(ids[i], DownloadInfo::EScope, scope);

            createDownload(ids[i], (DownloadScope)scope);

        }

    }

    return;

}

// generate unique id for download

long DownloadManager::generateDlId()

{

    DM_PRIVATE(DownloadManager);

    long id = 1;

    long totDls = (priv->m_parallelManager->currentDownloads().count() + 

                priv->m_sequentialManager->currentDownloads().count() +

                priv->m_backgroundManager->currentDownloads().count());

    if(totDls <= 0)

    {

        return id;

    }

    while(1)

    {