#include <algorithm>

#include <functional>

#include "updatechecker.h"

// This link returns the list of downloads in JSON format. Note that we only use

// the first page because results are sorted new to old.

const char BB_DOWNLOADS_URL[] = "https://api.bitbucket.org/2.0/repositories/hyozd/serialplot/downloads?fields=values.name,values.links.self.href";

UpdateChecker::UpdateChecker(QObject *parent) :

    QObject(parent), nam(this)

{

    activeReply = NULL;

    connect(&nam, &QNetworkAccessManager::finished,

            this, &UpdateChecker::onReqFinished);

}

bool UpdateChecker::isChecking() const

{

    return activeReply != NULL && !activeReply->isFinished();

}

void UpdateChecker::checkUpdate()

{

    if (isChecking()) return;

    auto req = QNetworkRequest(QUrl(BB_DOWNLOADS_URL));

    activeReply = nam.get(req);

}

void UpdateChecker::cancelCheck()

{

    if (activeReply != NULL) activeReply->abort();

}

void UpdateChecker::onReqFinished(QNetworkReply* reply)

{

    if (reply->error() != QNetworkReply::NoError)

    {

        emit checkFailed(QString("Network error: ") + reply->errorString());

    }

    else

    {

        QJsonParseError error;

        auto data = QJsonDocument::fromJson(reply->readAll(), &error);

        if (error.error != QJsonParseError::NoError)

        {

            emit checkFailed(QString("JSon parsing error: ") + error.errorString());

        }

        else

        {

            QList<FileInfo> files;

            if (!parseData(data, files))

            {

                // TODO: emit detailed data contents for logging

                emit checkFailed("Data parsing error.");

            }

            else

            {

                FileInfo updateFile;

                if (findUpdate(files, updateFile))

                {

                    emit checkFinished(

                        true, updateFile.version.toString(), updateFile.link);

                }

                else

                {

                    emit checkFinished(false, "", "");

                }

            }

        }

    }

    reply->deleteLater();

    activeReply = NULL;

}

bool UpdateChecker::parseData(const QJsonDocument& data, QList<FileInfo>& files) const

{

    /* Data is expected to be in this form:

    {

       "values": [

       {

         "name": "serialplot-0.9.1-x86_64.AppImage",

         "links": {

           "self": {

             "href": "https://api.bitbucket.org/2.0/repositories/hyOzd/serialplot/downloads/serialplot-0.9.1-x86_64.AppImage"

            }

          }

       }, ... ]

    }

    */

    if (!data.isObject()) return false;

    if (values == QJsonValue::Undefined || !values.isArray()) return false;

    for (auto value : values.toArray())

    {

        if (!value.isObject()) return false;

        auto name = value.toObject().value("name");

        if (name.isUndefined() || !name.isString())

             return false;

        auto links = value.toObject().value("links");

        if (links.isUndefined() || !links.isObject())

            return false;

        auto self = links.toObject().value("self");

        if (self.isUndefined() || !self.isObject())

            return false;

        auto href = self.toObject().value("href");

        if (href.isUndefined() || !href.isString())

            return false;

        FileInfo finfo;

        finfo.name = name.toString();

        finfo.link = href.toString();

        finfo.hasVersion = VersionNumber::extract(name.toString(), finfo.version);

        if (finfo.name.contains("amd64") ||

            finfo.name.contains("x86_64") ||

            finfo.name.contains("win64"))

        {

            finfo.arch = FileArch::amd64;

        }

        else if (finfo.name.contains("win32") ||

                 finfo.name.contains("i386"))

        {

            finfo.arch = FileArch::_i386;

        }

        else

        {

            finfo.arch = FileArch::unknown;

        }

        files += finfo;

    }

    return true;

}

bool UpdateChecker::findUpdate(const QList<FileInfo>& files, FileInfo& foundFile) const

{

    QList<FileInfo> fflist;

    // filter the file list according to extension and version number

    for (int i = 0; i < files.length(); i++)

    {

        // file type to look

#if defined(Q_OS_WIN)

        const char ext[] = ".exe";

#else  // of course linux

        const char ext[] = ".appimage";

#endif

        // file architecture to look

#if defined(Q_PROCESSOR_X86_64)

        const FileArch arch = FileArch::amd64;

#elif defined(Q_PROCESSOR_X86_32)

        const FileArch arch = FileArch::_i386;

#elif defined(Q_PROCESSOR_ARM)

        const FileArch arch = FileArch::arm;

#else

        #error Unknown architecture for update file detection.

#endif

        // filter the file list

        auto file = files[i];

        if (file.name.contains(ext, Qt::CaseInsensitive) &&

            file.arch == arch &&

            file.hasVersion && file.version > CurrentVersion)

        {

            fflist += file;

        }

    }

    // sort and find most up to date file

    if (!fflist.empty())

    {

        std::sort(fflist.begin(), fflist.end(),

                  [](const FileInfo& a, const FileInfo& b)

                  {

                      return a.version > b.version;

                  });

        foundFile = fflist[0];

        return true;

    }