/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

*

*

*

*/

#include "downloadcontroller.h"

#include "downloadcontroller_p.h"

#include <QNetworkProxy>

#include <QNetworkReply>

#include <QNetworkRequest>

#include <QString>

#include <QUrl>

#include <QWebPage>

#ifdef USE_DOWNLOAD_MANAGER

#include "download.h"

#include "downloadmanager.h"

static const char * downloadErrorToString(QNetworkReply::NetworkError error)

{

    switch (error) {

    case QNetworkReply::NoError:

        return "QNetworkReply::NoError";

    case QNetworkReply::ConnectionRefusedError:

        return "QNetworkReply::ConnectionRefusedError";

    case QNetworkReply::RemoteHostClosedError:

        return "QNetworkReply::RemoteHostClosedError";

    case QNetworkReply::HostNotFoundError:

        return "QNetworkReply::HostNotFoundError";

    case QNetworkReply::TimeoutError:

        return "QNetworkReply::TimeoutError";

    case QNetworkReply::OperationCanceledError:

        return "QNetworkReply::OperationCanceledError";

    case QNetworkReply::SslHandshakeFailedError:

        return "QNetworkReply::SslHandshakeFailedError";

    case QNetworkReply::ProxyConnectionRefusedError:

        return "QNetworkReply::ProxyConnectionRefusedError";

    case QNetworkReply::ProxyConnectionClosedError:

        return "QNetworkReply::ProxyConnectionClosedError";

    case QNetworkReply::ProxyNotFoundError:

        return "QNetworkReply::ProxyNotFoundError";

    case QNetworkReply::ProxyTimeoutError:

        return "QNetworkReply::ProxyTimeoutError";

    case QNetworkReply::ProxyAuthenticationRequiredError:

        return "QNetworkReply::ProxyAuthenticationRequiredError";

    case QNetworkReply::ContentAccessDenied:

        return "QNetworkReply::ContentAccessDenied";

    case QNetworkReply::ContentOperationNotPermittedError:

        return "QNetworkReply::ContentOperationNotPermittedError";

    case QNetworkReply::ContentNotFoundError:

        return "QNetworkReply::ContentNotFoundError";

    case QNetworkReply::AuthenticationRequiredError:

        return "QNetworkReply::AuthenticationRequiredError";

    case QNetworkReply::ContentReSendError:

        return "QNetworkReply::ContentReSendError";

    case QNetworkReply::ProtocolUnknownError:

        return "QNetworkReply::ProtocolUnknownError";

    case QNetworkReply::ProtocolInvalidOperationError:

        return "QNetworkReply::ProtocolInvalidOperationError";

    case QNetworkReply::UnknownNetworkError:

        return "QNetworkReply::UnknownNetworkError";

    case QNetworkReply::UnknownProxyError:

        return "QNetworkReply::UnknownProxyError";

    case QNetworkReply::UnknownContentError:

        return "QNetworkReply::UnknownContentError";

    case QNetworkReply::ProtocolFailure:

        return "QNetworkReply::ProtocolFailure";

    default:

        return 0;

    }

}

static const char * downloadEventToString(DEventType type)

{

    switch (type) {

    case DownloadCreated:

        return "DownloadManager:DownloadCreated";

    case DownloadsCleared:

        return "DownloadManager:DownloadsCleared";

    case ConnectedToServer:

        return "DownloadManager:ConnectedToServer";

    case DisconnectedFromServer:

        return "DownloadManager:DisconnectedFromServer";

    case ServerError:

        return "DownloadManager:ServerError";

    case Started:

        return "Download:Started";

    case HeaderReceived:

        return "Download:HeaderReceived";

    case Progress:

        return "Download:Progress";

    case Completed:

        return "Download:Completed";

    case Paused:

        return "Download:Paused";

    case Cancelled:

        return "Download:Cancelled";

    case Failed:

        return "Download:Failed";

    case DescriptorUpdated:

        return "Download:DescriptorUpdated";

    case NetworkLoss:

        return "Download:NetworkLoss";

    case Error:

        return "Download:Error";

    case OMADownloadDescriptorReady:

        return "Download:OMADownloadDescriptorReady";

    case WMDRMLicenseAcquiring:

        return "Download:WMDRMLicenseAcquiring";

    default:

        return 0;

    }

}

static const char * downloadPriorityToString(DownloadPriority priority)

{

    switch (priority) {

    case High:

        return "High";

    case Low:

        return "Low";

    default:

        return 0;

    }

}

static const char * downloadScopeToString(DownloadScope scope)

{

    switch (scope) {

    case Normal:

        return "Normal";

    case Background:

        return "Background";

    default:

        return 0;

    }

}

static const char * downloadStateToString(DownloadState state)

{

    switch (state) {

    case DlNone:

	return "DlNone";

    case DlCreated:

	return "DlCreated";

    case DlStarted:

	return "DlStarted";

    case DlInprogress:

	return "DlInprogress";

    case DlPaused:

	return "DlPaused";

    case DlCompleted:

	return "DlCompleted";

    case DlFailed:

	return "DlFailed";

    case DlCancelled:

	return "DlCancelled";

    case DlDescriptorUpdated:

	return "DlDescriptorUpdated";

    default:

        return 0;

    }

}

static const char * downloadTypeToString(DownloadType type)

{

    switch (type) {

    case Parallel:

        return "Parallel";

    case Sequential:

        return "Sequential";

    default:

        return 0;

    }

}

static void debugDownloadStr(

    Download * download,

    DownloadAttribute attribute,

    const char * name)

{

    QString value = download->getAttribute(attribute).toString();

    if (value.length() == 0) {

        return;

    }

    qDebug() << "DL" << download->id() << name << value;

}

static void debugDownloadInt(

    Download * download,

    DownloadAttribute attribute,

    const char * name)

{

    int value = download->getAttribute(attribute).toInt();

    if (value == 0) {

        return;

    }

    qDebug() << "DL" << download->id() << name << value;

}

static void debugDownloadUInt(

    Download * download,

    DownloadAttribute attribute,

    const char * name)

{

    uint value = download->getAttribute(attribute).toUInt();

    if (value == 0) {

        return;

    }

    qDebug() << "DL" << download->id() << name << value;

}

static void debugDownloadError(

    Download * download,

    DownloadAttribute attribute,

    const char * name)

{

    int num = download->getAttribute(attribute).toInt();

    const char * str = downloadErrorToString(static_cast<QNetworkReply::NetworkError>(num));

    if (str == 0) {

        str = "???";

    }

    qDebug() << "DL" << download->id() << name << num << str;

}

static void debugDownloadPriority(

    Download * download,

    DownloadAttribute attribute,

    const char * name)

{

    int num = download->getAttribute(attribute).toInt();

    const char * str = downloadPriorityToString(static_cast<DownloadPriority>(num));

    if (str == 0) {

        str = "???";

    }

    qDebug() << "DL" << download->id() << name << num << str;

}

static void debugDownloadScope(

    Download * download,

    DownloadAttribute attribute,

    const char * name)

{

    int num = download->getAttribute(attribute).toInt();

    const char * str = downloadScopeToString(static_cast<DownloadScope>(num));

    if (str == 0) {

        str = "???";

    }

    qDebug() << "DL" << download->id() << name << num << str;

}

static void debugDownloadState(

    Download * download,

    DownloadAttribute attribute,

    const char * name)

{

    int num = download->getAttribute(attribute).toInt();

    const char * str = downloadStateToString(static_cast<DownloadState>(num));

    if (str == 0) {

        str = "???";

    }

    qDebug() << "DL" << download->id() << name << num << str;

}

static void debugDownloadType(

    Download * download,

    DownloadAttribute attribute,

    const char * name)

{

    int num = download->getAttribute(attribute).toInt();

    const char * str = downloadTypeToString(static_cast<DownloadType>(num));

    if (str == 0) {

        str = "???";

    }

    qDebug() << "DL" << download->id() << name << num << str;

}

void DownloadController::debugDownload(Download * download)

{

    debugDownloadState(download,

            DlDownloadState,

            "DlDownloadState");

    debugDownloadError(download,

            DlLastError,

            "DlLastError");

    debugDownloadStr(download,

            DlLastErrorString,

            "DlLastErrorString");

    debugDownloadStr(download,

            DlSourceUrl,

            "DlSourceUrl");

    debugDownloadStr(download,

            DlContentType,

            "DlContentType");

    debugDownloadStr(download,

            DlDestPath,

            "DlDestPath");

    debugDownloadStr(download,

            DlFileName,

            "DlFileName");

    debugDownloadInt(download,

            DlDownloadedSize,

            "DlDownloadedSize");

    debugDownloadInt(download,

            DlTotalSize,

            "DlTotalSize");

    debugDownloadInt(download,

            DlLastPausedSize,

            "DlLastPausedSize");

    debugDownloadInt(download,

            DlPercentage,

            "DlPercentage");

    debugDownloadStr(download,

            DlStartTime,

            "DlStartTime");

    debugDownloadStr(download,

            DlEndTime,

            "DlEndTime");

    debugDownloadUInt(download,

            DlElapsedTime,

            "DlElapsedTime");

    debugDownloadStr(download,

            DlRemainingTime,

            "DlRemainingTime");

    debugDownloadStr(download,

            DlSpeed,

            "DlSpeed");

    debugDownloadScope(download,

            DlDownloadScope,

            "DlDownloadScope");

    debugDownloadType(download,

            DlDownloadType,

            "DlDownloadType");

    debugDownloadPriority(download,

            DlPriority,

            "DlPriority");

    debugDownloadInt(download,

            DlProgressInterval,

            "DlProgressInterval");

    debugDownloadStr(download,

            OMADownloadDescriptorName,

            "OMADownloadDescriptorName");

    debugDownloadStr(download,

            OMADownloadDescriptorVersion,

            "OMADownloadDescriptorVersion");

    debugDownloadStr(download,

            OMADownloadDescriptorType,

            "OMADownloadDescriptorType");

    debugDownloadStr(download,

            OMADownloadDescriptorSize,

            "OMADownloadDescriptorSize");

    debugDownloadStr(download,

            OMADownloadDescriptorVendor,

            "OMADownloadDescriptorVendor");

    debugDownloadStr(download,

            OMADownloadDescriptorDescription,

            "OMADownloadDescriptorDescription");

    debugDownloadStr(download,

            OMADownloadDescriptorNextURL,

            "OMADownloadDescriptorNextURL");

}

static void debugDownloadEvent(DEventType type)

{

    const char * name = downloadEventToString(type);

    if (name == 0) {

        return;

    }

    qDebug() << "Received event" << name;

}

// DownloadControllerPrivate implementation

DownloadControllerPrivate::DownloadControllerPrivate(

    DownloadController * downloadController,

    const QString & client,

    const QNetworkProxy & proxy)

{

    m_downloadController = downloadController;

    m_downloadManager = new DownloadManager(client);

    m_downloadManager->registerEventReceiver(this);

    if (proxy.type() != QNetworkProxy::NoProxy)

        m_downloadManager->setProxy(proxy.hostName(), proxy.port());

}

DownloadControllerPrivate::~DownloadControllerPrivate()

{

    delete m_downloadManager;

}

static QString downloadFileName(QUrl url)

{

    QString scheme = url.scheme();

    // For http and https, let the download manager determine the filename.

    if (scheme == "http" || scheme == "https")

        return QString();

    // For data scheme (see http://en.wikipedia.org/wiki/Data_URI_scheme)

    // we don't have a file name per-se, so construct one from the content

    // type.

    if (scheme == "data") {

        // Typical example: data:image/png;base64,...

        QString path = url.path();

        QString type = path.section('/', 0, 0);

        QString subtype = path.section('/', 1, 1).section(';', 0, 0);

        // For now we just use type as base name and subtype

        // as extension.  For the common case of image/jpg

        // and stuff like that this works fine.

        return type + "." + subtype;

    }

    // For all other schemes, let the download manager determine the filename.

    return QString();

}

void DownloadControllerPrivate::startDownload(QNetworkReply * reply)

{

    QUrl url = reply->url();

    Download * download = m_downloadManager->createDownload(reply);

    startDownload(download, url);

}

void DownloadControllerPrivate::startDownload(const QNetworkRequest & request)

{

    QUrl url = request.url();

    Download * download = m_downloadManager->createDownload(url.toString());

    startDownload(download, url);

}

void DownloadControllerPrivate::startDownload(Download * download, const QUrl & url)

{

    // If necessary suggest an alternate file name.

    // The download manager will adjust the file name for us to handle

    // duplicates in the destination directory.

    QString file = downloadFileName(url);

    if (file.length() > 0) {

        QVariant value(file);

        download->setAttribute(DlFileName, value);

    }

    // Start download.

    emit m_downloadController->downloadCreated(download);