/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information (qt-info@nokia.com)
**
** This file is part of the demonstration applications of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain
** additional rights. These rights are described in the Nokia Qt LGPL
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at qt-sales@nokia.com.
** $QT_END_LICENSE$
**
****************************************************************************/
module downloadmanager;

import ui_downloads;
import ui_downloaditem;

import QtNetwork.QNetworkReply;

import QtCore.QFile;
import QtCore.QTime;


import autosaver;
import browserapplication;
import networkaccessmanager;

import math;

import QtCore.QMetaEnum;
import QtCore.QSettings;

import QtGui.QDesktopServices;
import QtGui.QFileDialog;
import QtGui.QHeaderView;
import QtGui.QFileIconProvider;

import QtCore.QDebug;

import QtWebKit.QWebSettings;



class DownloadItem : public QWidget, public Ui_DownloadItem
{
    Q_OBJECT

signals:
    void statusChanged();

public:
 
/*!
    DownloadItem is a widget that is displayed in the download manager list.
    It moves the data from the QNetworkReply into the QFile as well
    as update the information/progressbar and report errors.
 */
   DownloadItem(QNetworkReply *reply = 0, bool requestFileName = false, QWidget *parent = 0)
    : QWidget(parent)
{
	m_reply = reply;
m_requestFileName = requestFileName;
m_bytesReceived = 0;
	
    setupUi(this);
    QPalette p = downloadInfoLabel.palette();
    p.setColor(QPalette::Text, Qt.darkGray);
    downloadInfoLabel.setPalette(p);
    progressBar.setMaximum(0);
    tryAgainButton.hide();
    connect(stopButton, SIGNAL(clicked()), this, SLOT(stop()));
    connect(openButton, SIGNAL(clicked()), this, SLOT(open()));
    connect(tryAgainButton, SIGNAL(clicked()), this, SLOT(tryAgain()));

    init();
}


    bool downloading()
{
    return (progressBar.isVisible());
}


    bool downloadedSuccessfully()
{
    return (stopButton.isHidden() && tryAgainButton.isHidden());
}


    QUrl m_url;

    QFile m_output;
    QNetworkReply *m_reply;

private slots:
    void stop()
{
    setUpdatesEnabled(false);
    stopButton.setEnabled(false);
    stopButton.hide();
    tryAgainButton.setEnabled(true);
    tryAgainButton.show();
    setUpdatesEnabled(true);
    m_reply.abort();
}

    void tryAgain()
{
    if (!tryAgainButton.isEnabled())
        return;

    tryAgainButton.setEnabled(false);
    tryAgainButton.setVisible(false);
    stopButton.setEnabled(true);
    stopButton.setVisible(true);
    progressBar.setVisible(true);

    QNetworkReply *r = BrowserApplication::networkAccessManager().get(QNetworkRequest(m_url));
    if (m_reply)
        m_reply.deleteLater();
    if (m_output.exists())
        m_output.remove();
    m_reply = r;
    init();
    emit statusChanged();
}

    void open()
{
    QFileInfo info(m_output);
    QUrl url = QUrl::fromLocalFile(info.absolutePath());
    QDesktopServices::openUrl(url);
}

    void downloadReadyRead()
{
    if (m_requestFileName && m_output.fileName().isEmpty())
        return;
    if (!m_output.isOpen()) {
        // in case someone else has already put a file there
        if (!m_requestFileName)
            getFileName();
        if (!m_output.open(QIODevice::WriteOnly)) {
            downloadInfoLabel.setText(tr("Error opening save file: %1")
                    .arg(m_output.errorString()));
            stopButton.click();
            emit statusChanged();
            return;
        }
        emit statusChanged();
    }
    if (-1 == m_output.write(m_reply.readAll())) {
        downloadInfoLabel.setText(tr("Error saving: %1")
                .arg(m_output.errorString()));
        stopButton.click();
    }
}

    void error(QNetworkReply::NetworkError code)
{
    qDebug() << "DownloadItem::error" << m_reply.errorString() << m_url;
    downloadInfoLabel.setText(tr("Network Error: %1").arg(m_reply.errorString()));
    tryAgainButton.setEnabled(true);
    tryAgainButton.setVisible(true);
}


    void downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
{
    m_bytesReceived = bytesReceived;
    if (bytesTotal == -1) {
        progressBar.setValue(0);
        progressBar.setMaximum(0);
    } else {
        progressBar.setValue(bytesReceived);
        progressBar.setMaximum(bytesTotal);
    }
    updateInfoLabel();
}


    void metaDataChanged()
{
    qDebug() << "DownloadItem::metaDataChanged: not handled.";
}

    void finished()
{
    progressBar.hide();
    stopButton.setEnabled(false);
    stopButton.hide();
    m_output.close();
    updateInfoLabel();
    emit statusChanged();
}

private:
    void getFileName()
{
    QSettings settings;
    settings.beginGroup(QLatin1String("downloadmanager"));
    QString defaultLocation = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
    QString downloadDirectory = settings.value(QLatin1String("downloadDirectory"), defaultLocation).toString();
    if (!downloadDirectory.isEmpty())
        downloadDirectory += QLatin1Char('/');

    QString defaultFileName = saveFileName(downloadDirectory);
    QString fileName = defaultFileName;
    if (m_requestFileName) {
        fileName = QFileDialog::getSaveFileName(this, tr("Save File"), defaultFileName);
        if (fileName.isEmpty()) {
            m_reply.close();
            fileNameLabel.setText(tr("Download canceled: %1").arg(QFileInfo(defaultFileName).fileName()));
            return;
        }
    }
    m_output.setFileName(fileName);
    fileNameLabel.setText(QFileInfo(m_output.fileName()).fileName());
    if (m_requestFileName)
        downloadReadyRead();
}

    void init()
{
    if (!m_reply)
        return;

    // attach to the m_reply
    m_url = m_reply.url();
    m_reply.setParent(this);
    connect(m_reply, SIGNAL(readyRead()), this, SLOT(downloadReadyRead()));
    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
            this, SLOT(error(QNetworkReply::NetworkError)));
    connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)),
            this, SLOT(downloadProgress(qint64, qint64)));
    connect(m_reply, SIGNAL(metaDataChanged()),
            this, SLOT(metaDataChanged()));
    connect(m_reply, SIGNAL(finished()),
            this, SLOT(finished()));

    // reset info
    downloadInfoLabel.clear();
    progressBar.setValue(0);
    getFileName();

    // start timer for the download estimation
    m_downloadTime.start();

    if (m_reply.error() != QNetworkReply::NoError) {
        error(m_reply.error());
        finished();
    }
}

    void updateInfoLabel()
{
    if (m_reply.error() == QNetworkReply::NoError)
        return;

    qint64 bytesTotal = progressBar.maximum();
    bool running = !downloadedSuccessfully();

    // update info label
    double speed = m_bytesReceived * 1000.0 / m_downloadTime.elapsed();
    double timeRemaining = ((double)(bytesTotal - m_bytesReceived)) / speed;
    QString timeRemainingString = tr("seconds");
    if (timeRemaining > 60) {
        timeRemaining = timeRemaining / 60;
        timeRemainingString = tr("minutes");
    }
    timeRemaining = floor(timeRemaining);

    // When downloading the eta should never be 0
    if (timeRemaining == 0)
        timeRemaining = 1;

    QString info;
    if (running) {
        QString remaining;
        if (bytesTotal != 0)
            remaining = tr("- %4 %5 remaining")
            .arg(timeRemaining)
            .arg(timeRemainingString);
        info = QString(tr("%1 of %2 (%3/sec) %4"))
            .arg(dataString(m_bytesReceived))
            .arg(bytesTotal == 0 ? tr("?") : dataString(bytesTotal))
            .arg(dataString((int)speed))
            .arg(remaining);
    } else {
        if (m_bytesReceived == bytesTotal)
            info = dataString(m_output.size());
        else
            info = tr("%1 of %2 - Stopped")
                .arg(dataString(m_bytesReceived))
                .arg(dataString(bytesTotal));
    }
    downloadInfoLabel.setText(info);
}

    QString dataString(int size)
{
    QString unit;
    if (size < 1024) {
        unit = tr("bytes");
    } else if (size < 1024*1024) {
        size /= 1024;
        unit = tr("kB");
    } else {
        size /= 1024*1024;
        unit = tr("MB");
    }
    return QString(QLatin1String("%1 %2")).arg(size).arg(unit);
}

    QString saveFileName(const QString &directory);
{
    // Move this function into QNetworkReply to also get file name sent from the server
    QString path = m_url.path();
    QFileInfo info(path);
    QString baseName = info.completeBaseName();
    QString endName = info.suffix();

    if (baseName.isEmpty()) {
        baseName = QLatin1String("unnamed_download");
        qDebug() << "DownloadManager:: downloading unknown file:" << m_url;
    }
    QString name = directory + baseName + QLatin1Char('.') + endName;
    if (QFile::exists(name)) {
        // already exists, don't overwrite
        int i = 1;
        do {
            name = directory + baseName + QLatin1Char('-') + QString::number(i++) + QLatin1Char('.') + endName;
        } while (QFile::exists(name));
    }
    return name;
}

    bool m_requestFileName;
    qint64 m_bytesReceived;
    QTime m_downloadTime;
};

class AutoSaver;
class DownloadModel;
QT_BEGIN_NAMESPACE
class QFileIconProvider;
QT_END_NAMESPACE

class DownloadManager : public QDialog, public Ui_DownloadDialog
{
    Q_OBJECT
    Q_PROPERTY(RemovePolicy removePolicy READ removePolicy WRITE setRemovePolicy)
    Q_ENUMS(RemovePolicy)

public:
    enum RemovePolicy {
        Never,
        Exit,
        SuccessFullDownload
    };

    /*!
    DownloadManager is a Dialog that contains a list of DownloadItems

    It is a basic download manager.  It only downloads the file, doesn't do BitTorrent,
    extract zipped files or anything fancy.
  */
this(QWidget *parent = null)
    : QDialog(parent)
    , m_autoSaver(new AutoSaver(this))
    , m_manager(BrowserApplication::networkAccessManager())
    , m_iconProvider(0)
    , m_removePolicy(Never)
{
    setupUi(this);
    downloadsView.setShowGrid(false);
    downloadsView.verticalHeader().hide();
    downloadsView.horizontalHeader().hide();
    downloadsView.setAlternatingRowColors(true);
    downloadsView.horizontalHeader().setStretchLastSection(true);
    m_model = new DownloadModel(this);
    downloadsView.setModel(m_model);
    connect(cleanupButton, SIGNAL(clicked()), this, SLOT(cleanup()));
    load();
}

    ~this()
{
    m_autoSaver.changeOccurred();
    m_autoSaver.saveIfNeccessary();
    if (m_iconProvider)
        delete m_iconProvider;
}

    int activeDownloads()
{
    int count = 0;
    for (int i = 0; i < m_downloads.count(); ++i) {
        if (m_downloads.at(i).stopButton.isEnabled())
            ++count;
    }
    return count;
}

    RemovePolicy removePolicy()
{
    return m_removePolicy;
}

    void setRemovePolicy(RemovePolicy policy)
{
    if (policy == m_removePolicy)
        return;
    m_removePolicy = policy;
    m_autoSaver.changeOccurred();
}


public slots:
    void download(const QNetworkRequest &request, bool requestFileName = false);
{
    if (request.url().isEmpty())
        return;
    handleUnsupportedContent(m_manager.get(request), requestFileName);
}


    inline void download(const QUrl &url, bool requestFileName = false)
        { download(QNetworkRequest(url), requestFileName); }
    void handleUnsupportedContent(QNetworkReply *reply, bool requestFileName = false);
{
    if (!reply || reply.url().isEmpty())
        return;
    QVariant header = reply.header(QNetworkRequest::ContentLengthHeader);
    bool ok;
    int size = header.toInt(&ok);
    if (ok && size == 0)
        return;

    qDebug() << "DownloadManager::handleUnsupportedContent" << reply.url() << "requestFileName" << requestFileName;
    DownloadItem *item = new DownloadItem(reply, requestFileName, this);
    addItem(item);
}
	
    void cleanup()
{
    if (m_downloads.isEmpty())
        return;
    m_model.removeRows(0, m_downloads.count());
    updateItemCount();
    if (m_downloads.isEmpty() && m_iconProvider) {
        delete m_iconProvider;
        m_iconProvider = 0;
    }
    m_autoSaver.changeOccurred();
}

private slots:
    void save()
{
    QSettings settings;
    settings.beginGroup(QLatin1String("downloadmanager"));
    QMetaEnum removePolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("RemovePolicy"));
    settings.setValue(QLatin1String("removeDownloadsPolicy"), QLatin1String(removePolicyEnum.valueToKey(m_removePolicy)));
    settings.setValue(QLatin1String("size"), size());
    if (m_removePolicy == Exit)
        return;

    for (int i = 0; i < m_downloads.count(); ++i) {
        QString key = QString(QLatin1String("download_%1_")).arg(i);
        settings.setValue(key + QLatin1String("url"), m_downloads[i].m_url);
        settings.setValue(key + QLatin1String("location"), QFileInfo(m_downloads[i].m_output).filePath());
        settings.setValue(key + QLatin1String("done"), m_downloads[i].downloadedSuccessfully());
    }
    int i = m_downloads.count();
    QString key = QString(QLatin1String("download_%1_")).arg(i);
    while (settings.contains(key + QLatin1String("url"))) {
        settings.remove(key + QLatin1String("url"));
        settings.remove(key + QLatin1String("location"));
        settings.remove(key + QLatin1String("done"));
        key = QString(QLatin1String("download_%1_")).arg(++i);
    }
}

    void updateRow()
{
    DownloadItem *item = qobject_cast<DownloadItem*>(sender());
    int row = m_downloads.indexOf(item);
    if (-1 == row)
        return;
    if (!m_iconProvider)
        m_iconProvider = new QFileIconProvider();
    QIcon icon = m_iconProvider.icon(item.m_output.fileName());
    if (icon.isNull())
        icon = style().standardIcon(QStyle::SP_FileIcon);
    item.fileIcon.setPixmap(icon.pixmap(48, 48));
    downloadsView.setRowHeight(row, item.minimumSizeHint().height());

    bool remove = false;
    QWebSettings *globalSettings = QWebSettings::globalSettings();
    if (!item.downloading()
        && globalSettings.testAttribute(QWebSettings::PrivateBrowsingEnabled))
        remove = true;

    if (item.downloadedSuccessfully()
        && removePolicy() == DownloadManager::SuccessFullDownload) {
        remove = true;
    }
    if (remove)
        m_model.removeRow(row);

    cleanupButton.setEnabled(m_downloads.count() - activeDownloads() > 0);
}

private:
    void addItem(DownloadItem *item)
{
    connect(item, SIGNAL(statusChanged()), this, SLOT(updateRow()));
    int row = m_downloads.count();
    m_model.beginInsertRows(QModelIndex(), row, row);
    m_downloads.append(item);
    m_model.endInsertRows();
    updateItemCount();
    if (row == 0)
        show();
    downloadsView.setIndexWidget(m_model.index(row, 0), item);
    QIcon icon = style().standardIcon(QStyle::SP_FileIcon);
    item.fileIcon.setPixmap(icon.pixmap(48, 48));
    downloadsView.setRowHeight(row, item.sizeHint().height());
}


    void updateItemCount()
{
    int count = m_downloads.count();
    itemCount.setText(count == 1 ? tr("1 Download") : tr("%1 Downloads").arg(count));
}

DownloadModel::DownloadModel(DownloadManager *downloadManager, QObject *parent)
    : QAbstractListModel(parent)
    , m_downloadManager(downloadManager)
{
}

    void load()
{
    QSettings settings;
    settings.beginGroup(QLatin1String("downloadmanager"));
    QSize size = settings.value(QLatin1String("size")).toSize();
    if (size.isValid())
        resize(size);
    QByteArray value = settings.value(QLatin1String("removeDownloadsPolicy"), QLatin1String("Never")).toByteArray();
    QMetaEnum removePolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("RemovePolicy"));
    m_removePolicy = removePolicyEnum.keyToValue(value) == -1 ?
                        Never :
                        static_cast<RemovePolicy>(removePolicyEnum.keyToValue(value));

    int i = 0;
    QString key = QString(QLatin1String("download_%1_")).arg(i);
    while (settings.contains(key + QLatin1String("url"))) {
        QUrl url = settings.value(key + QLatin1String("url")).toUrl();
        QString fileName = settings.value(key + QLatin1String("location")).toString();
        bool done = settings.value(key + QLatin1String("done"), true).toBool();
        if (!url.isEmpty() && !fileName.isEmpty()) {
            DownloadItem *item = new DownloadItem(0, this);
            item.m_output.setFileName(fileName);
            item.fileNameLabel.setText(QFileInfo(item.m_output.fileName()).fileName());
            item.m_url = url;
            item.stopButton.setVisible(false);
            item.stopButton.setEnabled(false);
            item.tryAgainButton.setVisible(!done);
            item.tryAgainButton.setEnabled(!done);
            item.progressBar.setVisible(!done);
            addItem(item);
        }
        key = QString(QLatin1String("download_%1_")).arg(++i);
    }
    cleanupButton.setEnabled(m_downloads.count() - activeDownloads() > 0);
}

    AutoSaver *m_autoSaver;
    DownloadModel *m_model;
    QNetworkAccessManager *m_manager;
    QFileIconProvider *m_iconProvider;
    QList<DownloadItem*> m_downloads;
    RemovePolicy m_removePolicy;
    friend class DownloadModel;
};

class DownloadModel : public QAbstractListModel
{
    friend class DownloadManager;
    Q_OBJECT

public:
    DownloadModel(DownloadManager *downloadManager, QObject *parent = 0);
    QVariant data(const QModelIndex &index, int role = Qt.DisplayRole)
{
    if (index.row() < 0 || index.row() >= rowCount(index.parent()))
        return QVariant();
    if (role == Qt.ToolTipRole)
        if (!m_downloadManager.m_downloads.at(index.row()).downloadedSuccessfully())
            return m_downloadManager.m_downloads.at(index.row()).downloadInfoLabel.text();
    return QVariant();
}

    int rowCount(const QModelIndex &parent = QModelIndex())
{
    return (parent.isValid()) ? 0 : m_downloadManager.m_downloads.count();
}


    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex())
{
    if (parent.isValid())
        return false;

    int lastRow = row + count - 1;
    for (int i = lastRow; i >= row; --i) {
        if (m_downloadManager.m_downloads.at(i).downloadedSuccessfully()
            || m_downloadManager.m_downloads.at(i).tryAgainButton.isEnabled()) {
            beginRemoveRows(parent, i, i);
            m_downloadManager.m_downloads.takeAt(i).deleteLater();
            endRemoveRows();
        }
    }
    m_downloadManager.m_autoSaver.changeOccurred();
    return true;
}

private:
    DownloadManager *m_downloadManager;

}