#include "downloadmanager.h"
#include "fbgui.h"

int DownloadManager::downloaded = 0;
// -------------------------------------------------------------------------------------------------------
DownloadManager::DownloadManager() {
   qxtLog->debug() << "Initializing download manager...";
   checkDownloadDirectory();
   _qnam = new QNetworkAccessManager();
   _qnam->moveToThread(&dmThread);
   dip = false;
}
DownloadManager::~DownloadManager() {
   delete _qnam;
}
// -------------------------------------------------------------------------------------------------------
void DownloadManager::checkDownloadDirectory() {
   // check if downloadPath exists, if not create it.
   downloadDir = QDir(downloadPath);
   if (!downloadDir.exists()) {
      qxtLog->debug() << "[dm] Download directory: " << downloadDir.path()
            << " doesn't exist.";
      // try to create the directory
      if (QDir::current().mkdir(downloadPath))
         qxtLog->debug() << "[dm] Created download directory: "
               << downloadDir.path();
      else {
         qxtLog->debug() << "[dm] Failed to create directory: "
               << downloadDir.path();
         // try to save to /tmp/fbgui
         downloadDir.setPath(QDir::tempPath() + "/fbgui");
         if (!downloadDir.exists()) {
            if (QDir::current().mkdir(QDir::tempPath() + "/fbgui"))
               qxtLog->debug() << "[dm] Successfully created: "
                     << downloadDir.absolutePath();
            else {
               // just in case
               qxtLog->debug() << "[dm] Failed to create: "
                     << downloadDir.absolutePath();
               qxtLog->debug() << "[dm] Exiting...";
               exit( EXIT_FAILURE);
            }
         } else
            qxtLog->debug() << "[dm] " << downloadDir.absolutePath()
                  << " already exists.";
      }
   } else
      qxtLog->debug() << "[dm] Download directory: "
            << downloadDir.absolutePath() << " already exists.";

   qxtLog->debug() << "[dm] Saving downloads to: "
         << downloadDir.absolutePath();
   downloadPath = downloadDir.absolutePath();
}
// -------------------------------------------------------------------------------------------------------
//                                         Public access
// -------------------------------------------------------------------------------------------------------
void DownloadManager::downloadFile(const QString& filename) {
   QUrl fileUrl(baseURL.resolved(QUrl(filename)));
   this->processDownloadRequest(fileUrl);
}
// -------------------------------------------------------------------------------------------------------
void DownloadManager::downloadFile(const QUrl& fileUrl) {
   this->processDownloadRequest(fileUrl);
}
// -------------------------------------------------------------------------------------------------------
//                    Private functions handling download requests and queueing
// -------------------------------------------------------------------------------------------------------
void DownloadManager::processDownloadRequest(const QUrl& url) {
   if (url.isEmpty()) {
      qxtLog->debug() << "[dm] No URL specified for download.";
      return;
   }
   qxtLog->debug() << "[dm] Enqueueing: " << url.toString();
   dlQ.enqueue(url);
   if (dip) {
      // download in progress, return.
      qxtLog->debug() << "[dm] Download in progress! Queued:" << url.toString()
            << "(" << dlQ.size() << " in queue)";
      return;
   }
   // no running downloads: start next in queue
   startNextDownload();
}
// -------------------------------------------------------------------------------------------------------
void DownloadManager::startNextDownload() {
   QWSServer::instance()->setCursorVisible(false);
   if (dlQ.isEmpty()) {
      emit downloadQueueEmpty();
      qxtLog->debug() << "[dm] Download manager ready. (1)";
      return;
   }
   qxtLog->debug() << "[dm] Starting next download: " << dlQ.head().toString()
         << "  (" << dlQ.size() - 1 << " in queue.)";

   // dequeue next URL to download.
   QUrl url = dlQ.dequeue();

   // get filename from URL.
   QString tmp = url.path();
   tmp.remove(0, tmp.lastIndexOf(QChar('/')) + 1);

   // check if filename exists on target file system
   if (downloadDir.exists(tmp)) {
      qxtLog->debug() << "[dm] File already exists: "
            << downloadDir.absoluteFilePath(tmp);
      outfile.setFileName(QString(downloadDir.absolutePath() + "/" + tmp
            + ".\%1").arg(downloaded));
   } else
      outfile.setFileName(downloadDir.absoluteFilePath(tmp));
   qxtLog->debug() << "[dm] Saving to: " << outfile.fileName();

   // try to open for writing
   if (!outfile.open(QIODevice::WriteOnly)) {
      qxtLog->debug() << "[dm] No write access to " << outfile.fileName()
            << " . Skipping download...";
      return;
   }

   // send the request for the file
   QNetworkRequest request(url);
   currentDownload = _qnam->get(request);
   lastProgress = 0;
   currentProgress = 0;
   dip = true;
   _time.start();
   QObject::connect(currentDownload, SIGNAL(readyRead()), this, SLOT(
         downloadReady()));
   QObject::connect(currentDownload, SIGNAL(metaDataChanged()), this, SLOT(
         processMetaInfo()));
   QObject::connect(currentDownload, SIGNAL(downloadProgress(qint64, qint64)),
         this, SLOT(downloadProgress(qint64, qint64)));
   QObject::connect(currentDownload, SIGNAL(finished()), this, SLOT(
         downloadFinished()));
}
// -------------------------------------------------------------------------------------------------------
//                           Private slots to handle a download in progress
// -------------------------------------------------------------------------------------------------------
void DownloadManager::processMetaInfo() {
   // fetch filesize from header & filename from URL (for now)
   const QByteArray cltag = "Content-Length";
   QByteArray clinfo = currentDownload->rawHeader(cltag);
   QFileInfo fi(outfile);
   qxtLog->debug() << "[dm] Download Info: " << fi.fileName() << " (Size: "
         << clinfo.toDouble() << ")";
   emit downloadInfo(fi.fileName(), clinfo.toDouble());
}
// -------------------------------------------------------------------------------------------------------
void DownloadManager::downloadReady() {
   // data ready, save it
   outfile.write(currentDownload->readAll());
}
// -------------------------------------------------------------------------------------------------------
void DownloadManager::downloadProgress(qint64 bytesIn, qint64 bytesTotal) {
   if (bytesIn > bytesTotal || bytesTotal <= 0) {
      qxtLog->debug() << "[dm] downloadProgress invalid values:" << "In:"
            << bytesIn << " / Total: " << bytesTotal;
      return;
   }
   // calculate current speed
   double speed = bytesIn * 1000 / _time.elapsed();
   QString unit;
   if (speed < 1024) {
      unit = "bytes/sec";
   } else if (speed < 1024 * 1024) {
      speed /= 1024;
      unit = "KB/s";
   } else {
      speed /= 1024 * 1024;
      unit = "MB/s";
   }
   // update progress only if difference higher than the updateInterval setting
   currentProgress = ((bytesIn * 100) / bytesTotal);
   if (currentProgress - lastProgress >= updateInterval) {
      lastProgress = currentProgress;
      emit updateProgress(currentProgress, speed, unit);
      qxtLog->debug() << "[dm] Download progress of "
            << currentDownload->url().toString() << ": " << bytesIn << "/"
            << bytesTotal << "(" << currentProgress << "\%)";
   }
}
// -------------------------------------------------------------------------------------------------------
void DownloadManager::downloadFinished() {
   // check for errors
   if (currentDownload->error()) {
      outfile.close();
      outfile.remove();
      int statusCode = currentDownload->attribute(
            QNetworkRequest::HttpStatusCodeAttribute).toInt();
      qxtLog->debug() << "[dm] Download of "
            << currentDownload->url().toString()
            << " failed with HTTP error code: " << statusCode;
      emit notify(QString("Download failed! HTTP Status Code: %1").arg(
            statusCode));
      currentDownload->deleteLater();
   } else {
      // end download
      outfile.close();
      downloaded++;
      qxtLog->debug() << "[dm] Download of "
            << currentDownload->url().toString() << " finished. (downloaded = "
            << downloaded << ")";
      emit notify(QString("Successfully downloaded %1").arg(
            currentDownload->url().toString()));
      currentDownload->deleteLater();
   }
   dip = false;
   // process next in queue, if any
   if (dlQ.isEmpty()) {
      emit downloadQueueEmpty();
      qxtLog->debug() << "[dm] Download manager ready. (2)";
      return;
   }
   startNextDownload();
}