/* Copyright 2018 WobLight
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "addon.h"
#include <QDir>
#include <git2.h>
#include <QDebug>
#include "control.h"
#ifdef Q_OS_WIN32
#include <windows.h>
#include <winbase.h>
#endif
#include <type_traits>
#include <QtConcurrent>
#include <QFutureWatcher>
#include <QReadWriteLock>

Addon::Addon(QString name, git_repository *repo, QObject *parent) : QObject(parent),
    m_name(name), m_repo(repo, &git_repository_free), m_progress(0), m_total(0), m_status(Status::Ready), m_gitStatus(GitStatusFlag::UpToDate), m_pool(new QThreadPool(this))
{
    connect(this, &Addon::remoteChanged, this, &Addon::fetchRemote);
    connect(this, &Addon::currentBranchChanged, this, &Addon::updateGitStatus);
    scanBranches();
}

QString Addon::name() const
{
    return m_name;
}

void Addon::setName(QString name)
{
    if (m_name == name)
        return;

    m_name = name;
    emit nameChanged(m_name);
}

void Addon::update()
{
    removeSubfolders();
    delegate("Update", [this](){
        git_reference *lbr = nullptr;
        git_reference *rbr = nullptr;
        git_reference *ubr = nullptr;
        int error = git_branch_lookup(&lbr, m_repo.get(), m_currentBranch.toLocal8Bit(), GIT_BRANCH_LOCAL);
        git_annotated_commit *ac;
        git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
        opts.checkout_strategy = GIT_CHECKOUT_FORCE;
        if (error == GIT_ENOTFOUND) {
            git_branch_lookup(&lbr, m_repo.get(), m_currentBranch.toLocal8Bit(), GIT_BRANCH_REMOTE);
            git_annotated_commit_from_ref(&ac, m_repo.get(), lbr);
        } else {
            git_branch_upstream(&rbr, lbr);
            git_annotated_commit_from_ref(&ac, m_repo.get(), rbr);
        }
        if (!git_branch_is_head(lbr))
            git_repository_set_head(m_repo.get(), git_reference_name(lbr));
        git_reference_set_target(&ubr, lbr, git_annotated_commit_id(ac), nullptr);
        git_checkout_head(m_repo.get(), &opts);

        git_annotated_commit_free(ac);
        if (rbr)
            git_reference_free(rbr);
        git_reference_free(lbr);
        git_reference_free(ubr);
    }, [this](){updateGitStatus();});
    unpackSubfolders();
}

void Addon::scanBranches()
{
    delegate("Branch Scan", [this](){
        struct {
            QStringList rs;
            QStringList bs;
            QString cb;
            QString cr;
        } data;
        git_strarray remotes;
        int error = git_remote_list(&remotes, m_repo.get());
        for (unsigned int i = 0; i < remotes.count; i++)
            data.rs << remotes.strings[i];
        git_strarray_free(&remotes);

        git_branch_iterator *iter = nullptr;
        error = git_branch_iterator_new(&iter, m_repo.get(), GIT_BRANCH_ALL);

        git_reference *ref = nullptr;
        const char *bname = nullptr;
        git_branch_t btype;
        while (!(error = git_branch_next(&ref, &btype, iter))) {
            git_branch_name(&bname, ref);
            data.bs << bname;
            if (git_branch_is_head(ref)) {
                data.cb = bname;
                git_buf buf = GIT_BUF_INIT_CONST(0, nullptr);
                (git_reference_is_remote(ref) ?
                            git_branch_remote_name :
                            git_branch_upstream_remote
                            )(&buf, m_repo.get(), git_reference_name(ref));
                data.cr = buf.ptr;
            }
            git_reference_free(ref);
        }
        git_branch_iterator_free(iter);
        return data;
    },[this](auto data){
        setRemote(data.cr);
        setCurrentBranch(data.cb);
        setRemotes(data.rs);
        setBranches(data.bs);
        scanSubfolders();
    });
}

void Addon::scanSubfolders()
{
    delegate("Subfolders Scan", [this](){
        QStringList sf;
        git_object *obj = nullptr;
        git_revparse_single(&obj, m_repo.get(), "HEAD^{tree}");
        git_tree *tree = reinterpret_cast<git_tree *>(obj);
        git_tree_walk(tree, GIT_TREEWALK_PRE, [](const char *root, const git_tree_entry *entry, void *payload) -> int{
            QString path = root;
            if (path.isEmpty())
                return 0;
            QStringList *sf = static_cast<QStringList *>(payload);
            QString file = git_tree_entry_name(entry);
            if (file.toLower() == path.toLower().chopped(1) + ".toc") {
                *sf << path.chopped(1);
                return 1;
            }
            if (path.split("/").size() > 1)
                return 1;
            return 0;
        }, &sf);
        git_object_free(obj);
        return sf;
    },[this](auto subs){setSubfolders(subs);});
}

void Addon::setBranches(QStringList branches)
{
    if (m_branches == branches)
        return;

    m_branches = branches;
    emit branchesChanged(m_branches);
}

void Addon::setCurrentBranch(QString currentBranch)
{
    if (m_currentBranch == currentBranch)
        return;

    m_currentBranch = currentBranch;
    emit currentBranchChanged(m_currentBranch);
}

void Addon::setRemote(QString remote)
{
    if (m_remote == remote)
        return;

    m_remote = remote;
    emit remoteChanged(m_remote);
}

void Addon::setRemotes(QStringList remotes)
{
    if (m_remotes == remotes)
        return;

    m_remotes = remotes;
    emit remotesChanged(m_remotes);
}

int fetch_progress_cb(const git_transfer_progress *stats, void *payload) {
    Addon *a = static_cast<Addon *>(payload);
    QMetaObject::invokeMethod(a,"setTotal",Q_ARG(int, stats->total_objects));
    QMetaObject::invokeMethod(a,"setProgress",Q_ARG(int, stats->received_objects));
    return 0;
}
void Addon::fetchRemote(QString remote)
{
    delegate(remote + " Fetch", [this, remote](){
        git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
        fetch_opts.callbacks.transfer_progress = &fetch_progress_cb;
        fetch_opts.callbacks.payload = this;
        git_remote *r;
        git_remote_lookup(&r, m_repo.get(), remote.toLocal8Bit());
        int error = git_remote_fetch(r,nullptr,&fetch_opts,nullptr);
        if (error < 0) {
            const git_error *e = giterr_last();
            qDebug() <<QString::asprintf("Error %d/%d: %s\n", error, e->klass, e->message);
        }
        git_remote_free(r);
    }, [this](){updateGitStatus();});

}

void Addon::setProgress(int fetchProgress)
{
    if (m_progress == fetchProgress)
        return;

    m_progress = fetchProgress;
    emit progressChanged(m_progress);
}

void Addon::setTotal(int fetchSize)
{
    if (m_total == fetchSize)
        return;

    m_total = fetchSize;
    emit totalChanged(m_total);
}

void Addon::setStatus(Addon::Status status)
{
    if (m_status == status)
        return;

    m_status = status;
    emit statusChanged(m_status);
}

void Addon::setGitStatus(Addon::GitStatus gitStatus)
{
    if (m_gitStatus == gitStatus)
        return;

    m_gitStatus = gitStatus;
    emit gitStatusChanged(m_gitStatus);
}

void Addon::updateGitStatus()
{
    delegate("Git Status Update", [this](){
        git_reference *tr;
        git_branch_lookup(&tr, m_repo.get(), m_currentBranch.toLocal8Bit(), GIT_BRANCH_LOCAL);
        if (!tr) {
            git_branch_lookup(&tr, m_repo.get(), m_currentBranch.toLocal8Bit(), GIT_BRANCH_REMOTE);
        }
        else {
            git_reference *rbr;
            git_branch_upstream(&rbr, tr);
            git_reference_free(tr);
            tr = rbr;
        }
        if (!tr)
            return GitStatusFlag::UpToDate;
        git_reference *lr;
        git_repository_head(&lr, m_repo.get());
        git_annotated_commit *uc;
        git_annotated_commit *lc;
        git_annotated_commit_from_ref(&uc, m_repo.get(), tr);
        git_annotated_commit_from_ref(&lc, m_repo.get(), lr);
        size_t ahead;
        size_t behind;
        git_graph_ahead_behind(&ahead, &behind, m_repo.get(), git_annotated_commit_id(lc), git_annotated_commit_id(uc));
        if (!(ahead || behind))
            return GitStatusFlag::UpToDate;
        else if (ahead && !behind)
            return GitStatusFlag::Ahead;
        else if (!ahead)
            return GitStatusFlag::Behind;
        else
            return GitStatusFlag::Diverged;


        git_reference_free(tr);
        git_reference_free(lr);
        git_annotated_commit_free(uc);
        git_annotated_commit_free(lc);
        /// TODO: check for local changes/merge
        /*if (git_repository_head_detached(m_repo.get())) {
            setGitStatus(GitStatus::Conflicting);
            return;
        }
        git_reference *tr;
        git_branch_lookup(&tr, m_repo.get(), m_currentBranch.toLocal8Bit(), GIT_BRANCH_LOCAL);
        if (!tr) {
            git_branch_lookup(&tr, m_repo.get(), m_currentBranch.toLocal8Bit(), GIT_BRANCH_REMOTE);
        }
        else {
            git_reference *rbr;
            git_branch_upstream(&rbr, tr);
            git_reference_free(tr);
            tr = rbr;
        }
        git_buf buf = GIT_BUF_INIT_CONST(0, nullptr);
        git_branch_remote_name(&buf, m_repo.get(), git_reference_name(tr));
        if (buf.ptr != remote())
            setRemote(buf.ptr);
        else {
            git_annotated_commit *ac;
            git_annotated_commit_from_ref(&ac, m_repo.get(), tr);
            git_merge_analysis_t an;
            git_merge_preference_t pref;
            git_merge_analysis(&an, &pref, m_repo.get(),(const git_annotated_commit **)&ac, 1);
            if (an & GIT_MERGE_ANALYSIS_UP_TO_DATE) {
                if (git_annotated_commit_id(*ac) != git_head)
                    setGitStatus(GitStatus::Conflicting);
                else
                    setGitStatus(GitStatus::UpToDate);
            }
            else if (an & GIT_MERGE_ANALYSIS_FASTFORWARD)
                setGitStatus(GitStatus::FastForwardable);
            else
                setGitStatus(GitStatus::Conflicting);

            git_annotated_commit_free(ac);
        }
        git_reference_free(tr);*/

    }, [this](auto s){
        setGitStatus(s);
    });
}

void Addon::uninstall()
{
    removeSubfolders();
    closeRepo();
    delegate("Removing addon folder", [this](){
        removeFolder(Control::instance()->addonsPath() + "/" + m_name);
    }, [](){Control::instance()->scanForAddons();});
}

void Addon::setSubfolders(QStringList subfolders)
{
    if (m_subfolders == subfolders)
        return;
    m_subfolders = subfolders;
    emit subfoldersChanged(m_subfolders);
}

void walkFolders(QFileInfo &info, auto f){
    if (info.isDir() && !info.isSymLink()) {
        foreach (QFileInfo sub, QDir(info.absoluteFilePath()).entryInfoList(QDir::AllEntries|QDir::NoDotAndDotDot|QDir::Hidden))
            walkFolders(sub, f);
    }
    f(info);
}

void Addon::removeFolder(QString path, bool ask) {
    QFileInfo info(path);
    QStringList files;
    bool ok = ask;
    if (info.exists()) {
        walkFolders(info, [&files](QFileInfo info){
            files << info.absoluteFilePath();
        });
        if (ask) {
            m_mutex.lock();
            m_result = &ok;
            QMetaObject::invokeMethod(this, "setFilesToRemove", Q_ARG(QString, files.join('\n')));
            m_wait.wait(&m_mutex);
            m_mutex.unlock();
        }
        if (ok) {
            emit totalChanged(files.size());
            for (int i = 0; i < files.size(); i++) {
                QFileInfo info(files[i]);
                if (!info.isSymLink() && info.isDir())
                    info.dir().rmdir(info.fileName());
                else
                    QFile(info.absoluteFilePath()).remove();
                emit totalChanged(i);
            }
        }
    }
}

void Addon::removeSubfolders()
{
    delegate("Removing Subfolders", [this](){
        foreach (QString subf, m_subfolders)
            removeFolder(Control::instance()->addonsPath() + "/" + subf);
    });
}

void Addon::unpackSubfolders(){
    delegate("Unpacking Subfolders", [this](){
        QStringList errors;
        QDir addonsDir(Control::instance()->addonsPath());
        if (m_subfolders.contains(m_name, Qt::CaseInsensitive)) {
            QString oldName = m_name;
            setName(m_name + ".repo");
            addonsDir.rename(oldName, m_name);
            openRepo();
        }
        QDir::setCurrent(addonsDir.canonicalPath());
        QDir dir(m_name);
        foreach (QString subfn, m_subfolders) {
            QFileInfo addonFolder(subfn);
            if (addonFolder.exists()) {
                QFileInfo dest(addonFolder.fileName() + ".bak");
                int i = 0;
                while (dest.exists())
                    dest = QFileInfo(addonFolder.fileName() + ".bak." + QString::number(++i));
                addonsDir.rename(addonFolder.fileName(), dest.fileName());
                if (QFileInfo(subfn).exists()) {
                    errors << QString("The folder \"%1\" already existed and couldn't be renamed. The addon subfolder has been skipped").arg(subfn, dest.exists());
                    continue;
                }
                errors << QString("The folder \"%1\" already existed and has been renamed to \"%2\"").arg(subfn, dest.fileName());
            }
    #ifdef Q_OS_WIN32
            QString link = subfn;
            link.replace("/","\\");
            QString target = "./"+m_name+"/"+subfn;
            target.replace("/","\\");
            wchar_t link_w[link.size() +1];
            wchar_t target_w[target.size() +1];
            int pos = link.toWCharArray(link_w);
            link_w[pos] = '\0';
            pos = target.toWCharArray(target_w);
            target_w[pos] = '\0';
    #else
            QFile::link("./"+m_name+"/"+subfn, subfn);
    #endif
            if (!QFileInfo(subfn).exists()) {
                dir.rename(subfn, "../"+subfn);
            }
            QFileInfo info(subfn);
            if (!info.exists()) {
                errors << "Failed to link or move \""+ info.absoluteFilePath() + "\" to \"" + addonFolder.absoluteFilePath()+"\"";
            }
        }
        return errors;
    }, [this](auto errors){
         if (errors.size() > 0) {
             setStatus(Status::Error);
             //setStatusMessage(errors.join('\n'));
         }
    });
}

void Addon::setFilesToRemove(QString filesToRemove)
{
    if (m_filesToRemove == filesToRemove)
        return;

    m_filesToRemove = filesToRemove;
    emit filesToRemoveChanged(m_filesToRemove);
}

void Addon::confirmFileRemove(bool confirmed)
{
    m_mutex.lock();
    *static_cast<bool *>(m_result) = confirmed;
    m_wait.wakeOne();
    m_mutex.unlock();
}

QStringList Addon::branches() const
{
    return m_branches;
}

QString Addon::currentBranch() const
{
    return m_currentBranch;
}

QString Addon::remote() const
{
    return m_remote;
}

QStringList Addon::remotes() const
{
    return m_remotes;
}

int Addon::progress() const
{
    return m_progress;
}

int Addon::total() const
{
    return m_total;
}

Addon::Status Addon::status() const
{
    return m_status;
}

Addon::GitStatus Addon::gitStatus() const
{
    return m_gitStatus;
}

QStringList Addon::subfolders() const
{
    return m_subfolders;
}

QString Addon::filesToRemove() const
{
    return m_filesToRemove;
}

void Addon::closeRepo()
{
    m_repo.reset();
}

void Addon::openRepo()
{
    git_repository *repo = nullptr;
    git_repository_open(&repo, (Control::instance()->addonsPath() + "/" + m_name).toLocal8Bit());
    m_repo.reset(repo);
}

void Addon::delegate(QString taskname, auto work, auto callback)
{
    Q_ASSERT_X(QThread::currentThread() == thread(), "delegate", "Attempt to delegate from another thread.");
    if (status() != Status::Ready) {
        qInfo() << name() << "Enqueueing" << taskname;
        m_tasks.enqueue({taskname, [this, taskname, work, callback](){delegate(taskname, work,callback);}});
        return;
    }
    qInfo() << name() << "Executing " << taskname;
    setProgress(0);
    setTotal(0);
    setStatus(Status::Busy);
    using ret_t = typename std::invoke_result<decltype(work)>::type;
    QFuture<ret_t> fut = QtConcurrent::run(m_pool, work);
    QFutureWatcher<ret_t> *fw = new QFutureWatcher<ret_t>();
    connect(fw, &QFutureWatcher<ret_t>::finished, [this, callback, fw](){
        setStatus(Status::Ready);
        TaskQueue old;
        m_tasks.swap(old);

        if constexpr (std::is_same<ret_t, void>::value)
            callback();
        else
            callback(fw->result());

        m_tasks.append(old);

        if (!m_tasks.isEmpty() && status() != Status::Busy)
            m_tasks.dequeue().second();
    });
    connect(fw, &QFutureWatcher<ret_t>::finished, fw, &QFutureWatcher<ret_t>::deleteLater);
    fw->setFuture(fut);
}

void Addon::delegate(QString taskname, auto work)
{
    using ret_t = typename std::invoke_result<decltype(work)>::type;
    if constexpr (std::is_same<ret_t, void>::value)
        delegate(taskname, work, [](){});
    else
        delegate(taskname, work, [](ret_t){});
}