#include "./resolvebuildorder.h"

#include "./packagefinder.h"
#include "./manager.h"
#include "./config.h"
#include "./utilities.h"
#include "./repository.h"

#include <c++utilities/misc/memory.h>

#include <QStringBuilder>
#include <QEventLoop>

#include <iostream>
#include <sstream>

using namespace std;
using namespace ApplicationUtilities;

namespace RepoIndex {

/*!
 * \brief The TaskInfo class defines a build task and provides the topo-sort required to resolve the build order.
 */
class TaskInfo
{
public:
    TaskInfo(const QString &name, bool onlyDependency = false, const QSet<TaskInfo *> &deps = QSet<TaskInfo *>());

    const QString &name() const;
    void setName(const QString &name);
    const QSet<TaskInfo *> deps() const;
    void addDep(TaskInfo *dep);
    bool areAllDepsAdded() const;
    void setAllDepsAdded();
    bool isDone() const;
    bool isVisited() const;
    bool isOnlyDependency() const;
    void setIsOnlyDependency(bool isOnlyDependency);
    bool isBinaryAvailable() const;
    void setBinaryAvailable(bool binaryAvailable);
    bool isPackageRequested() const;
    void setPackageRequested();
    QSet<Dependency> requiredFor() const;
    void addRequiredFor(const Dependency &dependency);
    void add(QList<TaskInfo *> &results);
    Package *associatedPackage() const;
    bool associatePackage(Package *package);
    static void addAll(const QList<TaskInfo *> &tasks, QList<TaskInfo *> &results);
    static TaskInfo *find(const QList<TaskInfo *> &tasks, const QString &name);

private:
    QString m_name;
    QSet<TaskInfo *> m_deps;
    bool m_allDepsAdded;
    bool m_done;
    bool m_visited;
    bool m_onlyDep;
    bool m_binaryAvailable;
    bool m_pkgRequested;
    QSet<Dependency> m_requiredFor;
    Package *m_associatedPackage;
};

/*!
 * \brief Constructs a new task.
 */
inline TaskInfo::TaskInfo(const QString &name, bool onlyDependency, const QSet<TaskInfo *> &deps) :
    m_name(name),
    m_deps(deps),
    m_allDepsAdded(false),
    m_done(false),
    m_visited(false),
    m_onlyDep(onlyDependency),
    m_binaryAvailable(false),
    m_pkgRequested(false),
    m_associatedPackage(nullptr)
{}

/*!
 * \brief Returns the name of the task.
 *
 * This is usually the name which has been specified when constructing
 * the task. However, the name might be adjusted to the package name
 * when a package is associated.
 */
inline const QString &TaskInfo::name() const
{
    return m_name;
}

inline void TaskInfo::setName(const QString &name)
{
    m_name = name;
}

/*!
 * \brief Returns the dependencies added via addDep().
 */
inline const QSet<TaskInfo *> TaskInfo::deps() const
{
    return m_deps;
}

/*!
 * \brief Adds another task as dependency.
 */
inline void TaskInfo::addDep(TaskInfo *dep)
{
    m_deps << dep;
}

/*!
 * \brief Returns whether setAllDepsAdded() has been called for this task.
 */
bool TaskInfo::areAllDepsAdded() const
{
    return m_allDepsAdded;
}

/*!
 * \brief Sets that all dependencies have been added for this task.
 */
void TaskInfo::setAllDepsAdded()
{
    m_allDepsAdded = true;
}

/*!
 * \brief Returns whether the task already has been added to the resulting list of tasks.
 * \sa add()
 */
inline bool TaskInfo::isDone() const
{
    return m_done;
}

/*!
 * \brief Returns whether the task has been visited.
 * \remarks Used to track circular dependencies (within add()).
 */
inline bool TaskInfo::isVisited() const
{
    return m_visited;
}

/*!
 * \brief Returns whether the task is only a dependency and none of the packages to be build.
 * \remarks Circular dependencies between packages which are only dependencies can be ignored.
 */
inline bool TaskInfo::isOnlyDependency() const
{
    return m_onlyDep;
}

/*!
 * \brief Sets whether the package is only a dependency.
 * \sa isOnlyDependency()
 */
inline void TaskInfo::setIsOnlyDependency(bool isOnlyDependency)
{
    m_onlyDep = isOnlyDependency;
}

/*!
 * \brief Returns whether a binary for the task is already available (from previous build).
 * \remarks If a binary is available the resolver won't complain if this package is a
 *          cyclic dependency.
 */
inline bool TaskInfo::isBinaryAvailable() const
{
    return m_binaryAvailable;
}

/*!
 * \brief Sets whether a binary for the task is already available (from previous build).
 * \sa isBinaryAvailable()
 */
inline void TaskInfo::setBinaryAvailable(bool binaryAvailable)
{
    m_binaryAvailable = binaryAvailable;
}

/*!
 * \brief Returns whether the package for this task has been requested yet.
 *
 * Used to avoid requesting the same package twice after the package
 * couldn't be found when requesting it the first time.
 */
inline bool TaskInfo::isPackageRequested() const
{
    return m_pkgRequested;
}

/*!
 * \brief Sets whether the package has been requested.
 *
 * This is set just before a package for this task is requrested.
 */
inline void TaskInfo::setPackageRequested()
{
    m_pkgRequested = true;
}

/*!
 * \brief Returns the dependencies the task has been added for.
 * \remarks
 *  - The same task can be added for multiple dependencies, eg.
 *    mingw-w64-extra-cmake-modules and mingw-w64-extra-cmake-modules=5.15.0.
 *  - The dependencies must be set explicitely using addRequiredFor().
 */
inline QSet<Dependency> TaskInfo::requiredFor() const
{
    return m_requiredFor;
}

/*!
 * \brief Adds the specified \a dependency to the list of dependencies the task has been added for.
 * \sa requiredFor()
 */
inline void TaskInfo::addRequiredFor(const Dependency &dependency)
{
    m_requiredFor << dependency;
}

/*!
 * \brief Adds the task to the specified list of results. Ensures that all dependencies are added before.
 * \throws If a circular dependency between the build tasks has been detected, the causing task is thrown.
 * \remarks Dependencies must be added via addDep() before calling this method.
 */
void TaskInfo::add(QList<TaskInfo *> &results)
{
    if(!isDone()) {
        if(isVisited()) {
            // cyclic dependency
            if(isOnlyDependency() || isBinaryAvailable()) {
                // if this is only a dependency (which we don't want to build) don't care about it
                // if there is already a binary (from previous build) don't care about it either
                return;
            } else {
                throw *this;
            }
        } else {
            m_visited = true;
        }
        for(auto *dep : deps()) {
            dep->add(results);
        }
        m_done = true;
        if(!isOnlyDependency()) {
            results << this;
        }
    }
}

/*!
 * \brief Returns the package associated via associatePackage().
 */
inline Package *TaskInfo::associatedPackage() const
{
    return m_associatedPackage;
}

/*!
 * \brief Associates the specified \a package with this build task.
 *
 * Does nothing if there is already a package assigned which matches all
 * dependencies the task has been added for. Returns true in this case.
 *
 * Fails if the specified \a package does not match all dependencies the task
 * has been added for.
 *
 * \return Returns whether either the currenlty assigned package or the specified
 *         \a package matches all dependencies the task has been added for.
 */
bool TaskInfo::associatePackage(Package *package)
{
    // check whether an appropriate package is already assigned
    // and whether the package matches all dependencies this task is required for
    bool assignmentRequired = !m_associatedPackage, assignmentPossible = true;
    for(const Dependency &dep : m_requiredFor) {
        if(!assignmentRequired && !m_associatedPackage->matches(dep)) {
            assignmentRequired = true;
        }
        if(!package->matches(dep)) {
            assignmentPossible = false;
        }
    }
    if(!assignmentRequired) {
        return true;
    }
    if(!assignmentPossible) {
        return false;
    }
    m_associatedPackage = package;
    // update the name to ensure we have the acutal package name and not just a "provides" name
    m_name = package->name();
    return true;
}

/*!
 * \brief Adds the specified \a tasks and their dependencies to the specified list of results. Ensures that all
 *        tasks are added in the right order.
 * \throws If a circular dependency between the build tasks has been detected, the causing task is thrown.
 * \remarks Dependencies must be added to the \a tasks via addDep() before calling this method.
 */
void TaskInfo::addAll(const QList<TaskInfo *> &tasks, QList<TaskInfo *> &results)
{
    for(auto *task : tasks) {
        task->add(results);
    }
}

/*!
 * \brief Finds the task with the specified \a name in the specified list of \a tasks.
 * \remarks Does not search dependencies the list does not contain.
 */
TaskInfo *TaskInfo::find(const QList<TaskInfo *> &tasks, const QString &name)
{
    for(auto *task : tasks) {
        if(task->name() == name) {
            return task;
        }
    }
    return nullptr;
}

/*!
 * \class BuildOrderResolver
 * \brief The BuildOrderResolver class resolves the build order for a specified array of packages.
 *
 * Resolving the build order is done in the following steps:
 * 1. instantiation: initial tasks are added
 * 2. findDependencies(): dependencies for each task are added, some packages might have to be requested first
 * 3. if some packages must be requested: wait for requested packages, if requested packages are available, go to 2.
 * 4. all dependencies are added: signal ready() is emitted
 * 5. resolve(): build order is resolved, either resolvingFinished() or resolvingFailed() is emitted
 */

/*!
 * \brief Creates a new BuildOrderResolver using the specified \a manager.
 */
BuildOrderResolver::BuildOrderResolver(Manager &manager, bool addSourceOnlyDeps, bool requireSources) :
    m_manager(manager),
    m_finder(nullptr),
    m_addSourceOnlyDeps(addSourceOnlyDeps),
    m_requireSources(requireSources),
    m_hasFinished(false)
{}

/*!
 * \brief Adds the specified \a errorMessage.
 */
void BuildOrderResolver::addError(const QString &errorMessage)
{
    if(!m_errorMessage.isEmpty()) {
        m_errorMessage.append(QStringLiteral(" \u2192 "));
    }
    m_errorMessage.append(errorMessage);
}

/*!
 * \brief Destroys the object.
 */
BuildOrderResolver::~BuildOrderResolver()
{
    qDeleteAll(m_tasks);
}

/*!
 * \brief Finds the dependencies of all packages.
 *
 * Also internally called after requested packages are available.
 */
void BuildOrderResolver::findDependencies()
{
    // find specified packages and their dependencies
    for(int i = 0, size = m_tasks.size(); i != size; ++i) {
        if(!addDependenciesToTask(m_tasks[i])) {
            return;
        }
    }
    // request dependencies to be requested
    requestDependenciesToBeRequested();
}

/*!
 * \brief Returns the resulting build order.
 * \remarks Build order must have been resolved yet.
 */
QStringList BuildOrderResolver::resultNames()
{
    QStringList names;
    names.reserve(m_results.size());
    for(const auto *res : m_results) {
        names << res->name();
    }
    return names;
}

/*!
 * \brief Prints relevant packages.
 * \remarks All dependencies must have been found yet.
 */
void BuildOrderResolver::printRelevantPackages()
{
    cerr << shchar << "Relevant packages:";
    for(const auto *task : m_tasks) {
        cerr << ' ' << task->name().toLocal8Bit().data();
    }
    cerr << endl;
}

/*!
 * \brief Prints the resulting build order.
 * \remarks Build order must have been resolved yet.
 */
void BuildOrderResolver::printResults()
{
    if(useShSyntax) {
        Utilities::printBashArray(cout, "REPOINDEX_RESULTS", resultNames());
    } else {
        Utilities::printValues(cout, "Results", resultNames());
    }
}

/*!
 * \brief Resolves the build order.
 * \remarks All dependencies must have been found yet.
 *
 * Emits either resolvingFinished() or resolvingFailed() depending on whether
 * the operation succeeded.
 */
void BuildOrderResolver::resolve()
{
    try {
        m_results.clear();
        m_results.reserve(m_tasks.size());
        TaskInfo::addAll(m_tasks, m_results);
        m_hasFinished = true;
        emit resolvingFinished();
    } catch(const TaskInfo &cyclic) {
        addError(QStringLiteral("Can't resolve build order; the package ") % cyclic.name() % QStringLiteral(" is a cyclic dependency."));
        m_hasFinished = true;
        emit resolvingFailed(m_errorMessage);
    }
}

/*!
 * \brief Returns the package for the specified \a dependency or nullptr if no package could be found.
 */
Package *BuildOrderResolver::findPackageForDependency(const Dependency &dependency, bool sourceRequired)
{
    Package *pkg;
    if(!sourceRequired && (pkg = m_manager.packageProviding(dependency))) {
        return pkg;
    } else if(m_finder && (pkg = m_finder->packageProviding(dependency))) {
        return pkg;
    }
    return nullptr;
}

/*!
 * \brief Finds the package for the specified \a task and then adds dependencies recursively.
 */
bool BuildOrderResolver::addDependenciesToTask(TaskInfo *task)
{
    // check whether dependencies have already been added
    if(task->areAllDepsAdded()) {
        // package associated -> dependencies already added
        return true;
    }
    Dependency dep(task->name(), QString());
    if(const auto pkg = findPackageForDependency(dep, m_requireSources && !task->isOnlyDependency())) {
        task->addRequiredFor(dep);
        if(task->associatePackage(pkg)) {
            if(pkg->repository()->isSourceOnly()) {
                if(m_addSourceOnlyDeps) {
                    task->setIsOnlyDependency(false);
                }
            } else {
                task->setBinaryAvailable(true);
            }
            // add dependencies to task
            task->setAllDepsAdded();
            if(!addDependenciesToTask(task, pkg->allDependencies())) {
                addError(QStringLiteral("Can not add dependencies of the dependency \"") % dep.toString() % QStringLiteral("\"."));
                m_hasFinished = true;
                emit resolvingFailed(errorMessage());
                return false;
            }
        } else {
            addError(QStringLiteral("Can not associate the task \"") % task->name() % QStringLiteral("\" with the package required by dependency \"") % dep.toString() % QStringLiteral("\"."));
            m_hasFinished = true;
            emit resolvingFailed(errorMessage());
            return false;
        }
    } else if(!task->isPackageRequested()) {
        task->setPackageRequested();
        m_dependenciesToBeRequested << dep;
    } else {
        addError(QStringLiteral("The specified package \"") % task->name() % QStringLiteral("\" could not be found."));
        m_hasFinished = true;
        emit resolvingFailed(errorMessage());
        return false;
    }
    return true;
}

/*!
 * \brief Finds packages for the the specified \a dependencies and adds them to the specified \a task.
 * \remarks Adds dependencies of the dependencies recursively.
 */
bool BuildOrderResolver::addDependenciesToTask(TaskInfo *task, const QList<const QList<Dependency> *> &dependencies)
{
    for(auto *deps : dependencies) {
        for(auto &dep : *deps) {
            auto *depTask = TaskInfo::find(m_tasks, dep.name);
            auto *depPkg = findPackageForDependency(dep, m_requireSources && depTask && !depTask->isOnlyDependency());
            const QString taskName = depPkg ? depPkg->name() : dep.name;
            bool newTask;
            if(depTask) {
                // we've already added a task for this dependency
                newTask = false;
            } else {
                // create new task
                m_tasks << (depTask = new TaskInfo(taskName, true));
                newTask = true;
            }
            // add dependency task to the dependencies of "parent" task
            task->addDep(depTask);
            depTask->addRequiredFor(dep);
            if(depPkg) {
                if(depTask->associatePackage(depPkg)) {
                    if(depPkg->repository()->isSourceOnly()) {
                        if(m_addSourceOnlyDeps) {
                            depTask->setIsOnlyDependency(false);
                        }
                    } else {
                        depTask->setBinaryAvailable(true);
                    }
                    if(!depTask->areAllDepsAdded()) {
                        // add dependencies of the dependency
                        depTask->setAllDepsAdded();
                        if(!addDependenciesToTask(depTask, depPkg->allDependencies())) {
                            addError(QStringLiteral("Can not add dependencies of the dependency \"") % dep.toString() % QStringLiteral("\"."));
                            return false;
                        }
                    }
                } else {
                    addError(QStringLiteral("Can not associate the task \"") % depTask->name() % QStringLiteral("\" with the package required by dependency \"") % dep.toString() % QStringLiteral("\"."));
                    return false;
                }
            } else {
                if(!m_dependenciesToBeRequested.contains(dep)) {
                    if(!depTask->isPackageRequested()) {
                        depTask->setPackageRequested();
                        m_dependenciesToBeRequested << dep;
                    } else {
                        addError(QStringLiteral("The specified package \"") % dep.toString() % QStringLiteral("\" could not be found."));
                        return false;
                    }
                }
            }
        }
    }
    return true;
}

/*!
 * \brief Requests dependencies to be requested.
 */
void BuildOrderResolver::requestDependenciesToBeRequested()
{
    // check whether there are dependencies to be requested
    if(!m_dependenciesToBeRequested.isEmpty()) {
        // print dependencies to be requested
        if(m_manager.config().isVerbose()) {
            cerr << shchar << "Dependencies to be requested:";
            for(const Dependency &dep : m_dependenciesToBeRequested) {
                cerr << ' ' << dep.name.toStdString();
            }
            cerr << endl;
        }

        // do requests (using package finder)
        m_finder = make_unique<PackageFinder>(m_manager, m_dependenciesToBeRequested, true);

        // all dependencies requested -> clear dependencies to be requested
        m_dependenciesToBeRequested.clear();

        // add results
        if(m_finder->areAllResultsAvailable()) {
            // results are immediately available (already cached)
            findDependencies();
        } else {
            // need to request actually
            connect(m_finder.get(), &PackageFinder::resultsAvailable, this, &BuildOrderResolver::findDependencies);
        }

    } else {
        // there are no dependencies to be requested -> ready to resolve build order
        emit ready();
    }
}

/*!
 * \class BuildOrderResolverCli
 * \brief The BuildOrderResolverCli class resolves the build order of the specified packages and prints the results stdout.
 */

/*!
 * \brief Creates a new BuildOrderResolverCli for the specified \a packages using the specified \a manager.
 */
BuildOrderResolverCli::BuildOrderResolverCli(Manager &manager, const std::vector<const char *> &packages, bool addSourceOnlyDeps, bool requireSources) :
    BuildOrderResolver(manager, addSourceOnlyDeps, requireSources)
{
    cerr << shchar << "Getting package information ..." << endl;
    tasks().clear();
    tasks().reserve(packages.size() * 2);
    // add a task for each specified package
    for(const char *pkgName : packages) {
        tasks() << new TaskInfo(QString::fromLocal8Bit(pkgName));
    }
}

/*!
 * \brief Determines dependencies, prints relevant packages, resolves build order, prints results/errors.
 * \remarks Does not return until everything is done.
 */
int BuildOrderResolverCli::exec()
{
    if(manager().config().isVerbose()) {
        connect(this, &BuildOrderResolver::ready, this, &BuildOrderResolver::printRelevantPackages);
    }
    connect(this, &BuildOrderResolver::ready, this, &BuildOrderResolver::resolve);
    connect(this, &BuildOrderResolver::resolvingFinished, this, &BuildOrderResolver::printResults);
    connect(this, &BuildOrderResolver::resolvingFailed, static_cast<void(*)(const QString &)>(Utilities::printError));
    QEventLoop loop;
    connect(this, &BuildOrderResolver::resolvingFinished, &loop, &QEventLoop::quit);
    connect(this, &BuildOrderResolver::resolvingFailed, &loop, &QEventLoop::quit);
    findDependencies();
    if(hasFinished()) {
        // resolving might have been finished immidiately
        return errorMessage().isEmpty();
    } else {
        // resolving not finished yet (deps must be requested)
        return loop.exec();
    }
}

} // namespace PackageManagement