/**
   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 "sequentialdownloadmanager.h"
#include "downloadevent.h"
#include "clientdownload.h"

class SequentialDownloadManagerPrivate
{
    //declare public implementation
    DM_DECLARE_PUBLIC(SequentialDownloadManager);
public:
    SequentialDownloadManagerPrivate();
    ~SequentialDownloadManagerPrivate();

    QList<Download*> m_createdDownloads; // list of downloads which have been created by the client and owns them
    QQueue<Download*> m_downloadsQueue; // queue of downloads scheduled for downloading and owns them
    QList<Download*> m_completedDownloads; // list of downloads which have been completed and owns them
    QList<Download*> m_failedDownloads; // list of failed downloads
    QList<Download*> m_totalDownloads; // total of all the above downloads, but this doesnt own downloads
};

SequentialDownloadManagerPrivate::SequentialDownloadManagerPrivate()
{ }

SequentialDownloadManagerPrivate::~SequentialDownloadManagerPrivate()
{
    int createdSize = m_createdDownloads.size();
    for (int i = 0; i < createdSize; i++)
        delete m_createdDownloads[i];
    m_createdDownloads.clear();

    int completedSize = m_completedDownloads.size();
    for (int i = 0; i < completedSize; i++)
        delete m_completedDownloads[i];
    m_completedDownloads.clear();

    int size = m_downloadsQueue.size();
    for (int i = 0; i < size; i++) {
        DownloadState state = (DownloadState)((m_downloadsQueue[i]->getAttribute(DlDownloadState)).toInt());
        if (state == DlInprogress) {
            // pause the download if it is in progress
            m_downloadsQueue[i]->pause();
        } else if (state == DlFailed) {
            // cancel the download if it has failed
            m_downloadsQueue[i]->cancel();
        }
        delete (m_downloadsQueue[i]);
    }
    m_downloadsQueue.clear();
}

/*
  constructor
*/
SequentialDownloadManager::SequentialDownloadManager()
{
    DM_INITIALIZE(SequentialDownloadManager);
}

/*
  destructor
*/
SequentialDownloadManager::~SequentialDownloadManager()
{
    DM_UNINITIALIZE(SequentialDownloadManager);
}

/*
  returns all the current downloads
*/
QList<Download*>& SequentialDownloadManager::currentDownloads()
{
    DM_PRIVATE(SequentialDownloadManager);
    priv->m_totalDownloads.clear();
    for (int i = 0; i < priv->m_completedDownloads.size(); ++i)
         priv->m_totalDownloads.append(priv->m_completedDownloads[i]);
    for (int i = 0; i < priv->m_downloadsQueue.size(); ++i)
        priv->m_totalDownloads.append(priv->m_downloadsQueue[i]);
    for (int i = 0; i < priv->m_createdDownloads.size(); ++i)
        priv->m_totalDownloads.append(priv->m_createdDownloads[i]);
    for (int i = 0; i < priv->m_failedDownloads.size(); ++i)
        priv->m_totalDownloads.append(priv->m_failedDownloads[i]);
    return priv->m_totalDownloads;
}

/*
  finds a download provided id if exists
  \a id indicates identifier for download
*/
Download* SequentialDownloadManager::findDownload(int dlId)
{
    DM_PRIVATE(SequentialDownloadManager);
    for (int i = 0; i < priv->m_completedDownloads.size(); ++i) {
        if (priv->m_completedDownloads[i]->id() == dlId)
            return priv->m_completedDownloads[i];
    }
    for (int i = 0; i < priv->m_downloadsQueue.size(); ++i) {
        if (priv->m_downloadsQueue[i]->id() == dlId)
            return priv->m_downloadsQueue[i];
    }
    for (int i = 0; i < priv->m_createdDownloads.size(); ++i) {
        if (priv->m_createdDownloads[i]->id() == dlId)
            return priv->m_createdDownloads[i];
    }
    return 0;
}

/*
  cancels all the downloads
*/
void SequentialDownloadManager::removeAll()
{
    DM_PRIVATE(SequentialDownloadManager);
    //traverse the list and delete each download in the list
    for(int i = 0; i < priv->m_downloadsQueue.count(); ) {
        // cancel the download
        priv->m_downloadsQueue[0]->cancel();
        delete (priv->m_downloadsQueue[0]);
        priv->m_downloadsQueue.removeAt(0);
    }
    priv->m_downloadsQueue.clear();

    int createdDownloadsCount = priv->m_createdDownloads.count();
    //traverse the list and delete each download in the list
    for(int i = 0; i < createdDownloadsCount; i++)
        delete (priv->m_createdDownloads[i]);
    priv->m_createdDownloads.clear();

    int completedDownloadsCount = priv->m_completedDownloads.count();
    //traverse the list and delete each download in the list
    for(int i = 0; i < completedDownloadsCount; i++)
        delete (priv->m_completedDownloads[i]);
    priv->m_completedDownloads.clear();

    int failedDownloadsCount = priv->m_failedDownloads.count();
    //traverse the list and delete each download in the list
    for(int i = 0; i < failedDownloadsCount; i++)
        delete (priv->m_failedDownloads[i]);
    priv->m_failedDownloads.clear();
}

/*
  cancels and removes the download
  \a dl indicates the download to be canceled and removed
*/
void SequentialDownloadManager::removeOne(Download *dl)
{
    if(!dl)
        return;
    DM_PRIVATE(SequentialDownloadManager);
    if (currentDownloads().contains(dl)) {
        dl->cancel();
        // download might be there in any of the following list
        priv->m_downloadsQueue.removeOne(dl);
        priv->m_createdDownloads.removeOne(dl);
        priv->m_completedDownloads.removeOne(dl);
        delete dl;
        dl = 0;
    }
}

/*
  pauses all the downloads which are in progress
*/
void SequentialDownloadManager::pauseAll()
{
    DM_PRIVATE(SequentialDownloadManager);
    if (!priv->m_downloadsQueue.isEmpty()) {
        QQueue<Download*>::iterator i;
        i = priv->m_downloadsQueue.begin();
        DownloadState state = (DownloadState)(((*i)->getAttribute(DlDownloadState)).toInt());
        if ((state == DlInprogress || state == DlStarted))
            dynamic_cast<ClientDownload*>(*i)->pauseDownload();
    }
}

/*
  resumes all the downloads which are paused
*/
void SequentialDownloadManager::resumeAll()
{
    DM_PRIVATE(SequentialDownloadManager);
    if (!priv->m_downloadsQueue.isEmpty()) {
        QQueue<Download*>::iterator i;
        i = priv->m_downloadsQueue.begin();
        DownloadState state = (DownloadState)(((*i)->getAttribute(DlDownloadState)).toInt());
        if (state == DlPaused)
            dynamic_cast<ClientDownload*>(*i)->resumeDownload();
    }
}

void SequentialDownloadManager::addToSequentialDownload(Download* dl)
{
    // Here the downloads are added first to a download list. When the downloads are in this list,
    // the client can set some attributes on the download.
    // Later the client has to explicitly call start() on the download after which,
    // download gets added to the downloadsQueue and the download starts.

    DM_PRIVATE(SequentialDownloadManager);

    // set the download type
    ClientDownload* download = dynamic_cast<ClientDownload*>(dl);
    if(download)
        download->attributes().insert(DlDownloadType, (int)Sequential);

    // if the download is already in queue but the prority has been changed
    if( findDownload(dl->id()))
        priv->m_createdDownloads.removeOne(dl);

    DownloadPriority priority = (DownloadPriority)(dl->getAttribute(DlPriority)).toInt();
    if (priority == High) {
        QList<Download*>::iterator i;
        for (i = priv->m_createdDownloads.begin(); i != priv->m_createdDownloads.end(); i++) {
            if ((*i)->getAttribute(DlPriority).toInt() == Low) {
                priv->m_createdDownloads.insert(i, dl);
                return;
            }
        }
        priv->m_createdDownloads.insert(i, dl); // if no low priority download is found then just insert the high priority download
    }
    else
        priv->m_createdDownloads.append(dl);
}

void SequentialDownloadManager::addToDownloadQueue(Download* dl)
{
    DM_PRIVATE(SequentialDownloadManager);
    priv->m_downloadsQueue.append(dl);
}

void SequentialDownloadManager::addToCompletedList(Download* dl)
{
    DM_PRIVATE(SequentialDownloadManager);
    priv->m_completedDownloads.append(dl);
}

void SequentialDownloadManager::process(int dlId)
{
    DM_PRIVATE(SequentialDownloadManager);
    // Start() has been called on a download present in the createdDownloads list. Move that download from the list to the queue
    ClientDownload* dl = dynamic_cast<ClientDownload*>(findDownload(dlId));
    dl->registerEventReceiver(this);
    priv->m_createdDownloads.removeOne(dl); // Once start() is called on download, add it to downloadQueue & remove it from createdDownloads list
    if (priv->m_downloadsQueue.isEmpty()) {
        addToDownloadQueue(dl);
        dl->startDownload();
        return;
    }
    DownloadPriority priority = (DownloadPriority)((dl->getAttribute(DlPriority)).toInt());
    // checking for priority
    if (priority == High) {
        // Add the download before the first low priority item
        QQueue<Download*>::iterator i;
        for (i = priv->m_downloadsQueue.begin(); i != priv->m_downloadsQueue.end(); i++) {
            if ((*i)->getAttribute(DlPriority).toInt() == Low) {
                if (i == priv->m_downloadsQueue.begin()) {
                    dynamic_cast<ClientDownload*>(*i)->pauseDownload();
                    priv->m_downloadsQueue.insert(i, dl); // low priority dl is in progress so pause it, insert the high priority dl and start it.
                    dl->startDownload();
                }
                else {
                    // low priority download is present in the queue but it's not the first one as it is not yet started,
                    // so there's already a high priority dl in progress. So this high priority dl should just be inserted into the queue.
                    priv->m_downloadsQueue.insert(i, dl);
                }
                return;
            }
        }
        priv->m_downloadsQueue.insert(i, dl); // insert the high priority download if there are no low priority downloads in the queue
    }
    else
        addToDownloadQueue(dl); // If priority is low then just append to the queue.
}

bool SequentialDownloadManager::event(QEvent *event)
{
    DM_PRIVATE(SequentialDownloadManager);
    DEventType type = (DEventType)event->type();
    switch(type) {
    case Completed:
    {
        int dlId = ((DownloadEvent*)event)->getId();
        ClientDownload *dl = dynamic_cast<ClientDownload*>(findDownload(dlId));
        addToCompletedList(dl);
        // After adding the download to completed list, remove it from downloadQueue
        priv->m_downloadsQueue.removeOne(dl);
        startNext();
        break;
    }
    case Error:
    {
        int dlId = ((DownloadEvent*)event)->getId();
        ClientDownload *dl = dynamic_cast<ClientDownload*>(findDownload(dlId));
        priv->m_failedDownloads.append(dl);
        priv->m_downloadsQueue.removeOne(dl);
        startNext();
        break;
    }
    default:
        break;
    }
    return true;
}

void SequentialDownloadManager::startNext()
{
    DM_PRIVATE(SequentialDownloadManager);
    QQueue<Download*>::iterator i;
    if (!priv->m_downloadsQueue.isEmpty()) {
        i = priv->m_downloadsQueue.begin();
        DownloadState state = (DownloadState)(((*i)->getAttribute(DlDownloadState)).toInt());
        if (state == DlPaused)
            (*i)->resume();
        else
            dynamic_cast<ClientDownload*>(*i)->startDownload();
    }
}

void SequentialDownloadManager::pauseDownload(int dlId)
{
    DM_PRIVATE(SequentialDownloadManager);
    QQueue<Download*>::iterator i;
    if (!priv->m_downloadsQueue.isEmpty()) {
        i = priv->m_downloadsQueue.begin();
        if (dlId == (*i)->id())
            dynamic_cast<ClientDownload*>(*i)->pauseDownload();
    }
}

void SequentialDownloadManager::resumeDownload(int dlId)
{
    DM_PRIVATE(SequentialDownloadManager);
    QQueue<Download*>::iterator i;
    if (!priv->m_downloadsQueue.isEmpty()) {
        i = priv->m_downloadsQueue.begin();
        if (dlId == (*i)->id())
            dynamic_cast<ClientDownload*>(*i)->resumeDownload();
    }
}

void SequentialDownloadManager::cancelDownload(int dlId)
{
    DM_PRIVATE(SequentialDownloadManager);
    QQueue<Download*>::iterator i;
    if (!priv->m_downloadsQueue.isEmpty()) {
        i = priv->m_downloadsQueue.begin();
        if (dlId == (*i)->id())
            dynamic_cast<ClientDownload*>(*i)->cancelDownload();
    }
}