/*
 * Copyright 2013-2014, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "PackageManager.h"

#include <Catalog.h>
#include <Notification.h>
#include <package/DownloadFileRequest.h>
#include <package/RefreshRepositoryRequest.h>
#include <package/solver/SolverPackage.h>
#include <package/solver/SolverPackageSpecifierList.h>
#include <package/solver/SolverProblem.h>
#include <package/solver/SolverProblemSolution.h>

#include <AutoDeleter.h>
#include <package/manager/Exceptions.h>
#include <package/manager/RepositoryBuilder.h>
#include <Server.h>

#include "ProblemWindow.h"
#include "ResultWindow.h"
#include "Root.h"
#include "Volume.h"

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "PackageManager"

using BPackageKit::BManager::BPrivate::BAbortedByUserException;
using BPackageKit::BManager::BPrivate::BFatalErrorException;
using BPackageKit::BManager::BPrivate::BRepositoryBuilder;


PackageManager::PackageManager(Root* root, Volume* volume)
        :
        BPackageManager(volume->Location(), this, this),
        BPackageManager::UserInteractionHandler(),
        fRoot(root),
        fVolume(volume),
        fSolverPackages(),
        fPackagesAddedByUser(),
        fPackagesRemovedByUser(),
        fProblemWindow(NULL)
{
}


PackageManager::~PackageManager()
{
        if (fProblemWindow != NULL)
                fProblemWindow->PostMessage(B_QUIT_REQUESTED);
}


void
PackageManager::HandleUserChanges()
{
        const PackageSet& packagesToActivate = fVolume->PackagesToBeActivated();
        const PackageSet& packagesToDeactivate = fVolume->PackagesToBeDeactivated();

        if (packagesToActivate.empty() && packagesToDeactivate.empty())
                return;

        if (packagesToActivate.empty()) {
                // only packages removed -- use uninstall mode
                Init(B_ADD_INSTALLED_REPOSITORIES);

                BSolverPackageSpecifierList packagesToUninstall;
                for (PackageSet::const_iterator it = packagesToDeactivate.begin();
                        it != packagesToDeactivate.end(); ++it) {
                        BSolverPackage* solverPackage = _SolverPackageFor(*it);
                        if (solverPackage == NULL)
                                continue;

                        if (!packagesToUninstall.AppendSpecifier(solverPackage))
                                throw std::bad_alloc();
                        fPackagesRemovedByUser.insert(solverPackage);
                }

                if (fPackagesRemovedByUser.empty())
                        return;

                Uninstall(packagesToUninstall);
        } else {
                // packages added and (possibly) remove -- manually add/remove those
                // from the repository and use verify mode
                Init(B_ADD_INSTALLED_REPOSITORIES | B_ADD_REMOTE_REPOSITORIES
                        | B_REFRESH_REPOSITORIES);

                // disable and remove uninstalled packages
                InstalledRepository& repository = InstallationRepository();
                for (PackageSet::const_iterator it = packagesToDeactivate.begin();
                        it != packagesToDeactivate.end(); ++it) {
                        BSolverPackage* solverPackage = _SolverPackageFor(*it);
                        if (solverPackage == NULL)
                                continue;

                        repository.DisablePackage(solverPackage);
                        if (!repository.PackagesToDeactivate().AddItem(solverPackage))
                                throw std::bad_alloc();
                        fPackagesRemovedByUser.insert(solverPackage);
                }

                // add new packages
                BRepositoryBuilder repositoryBuilder(repository);
                for (PackageSet::const_iterator it = packagesToActivate.begin();
                        it != packagesToActivate.end(); ++it) {
                        Package* package = *it;
                        BSolverPackage* solverPackage;
                        repositoryBuilder.AddPackage(package->Info(), NULL, &solverPackage);
                        fSolverPackages[package] = solverPackage;
                        if (!repository.PackagesToActivate().AddItem(solverPackage))
                                throw std::bad_alloc();
                        fPackagesAddedByUser.insert(solverPackage);
                }

                if (fPackagesRemovedByUser.empty() && fPackagesAddedByUser.empty())
                        return;

// TODO: When packages are moved out of the packages directory, we can't create
// a complete "old-state" directory.

                VerifyInstallation();
        }
}


void
PackageManager::InitInstalledRepository(InstalledRepository& repository)
{
        const char* name = repository.InitialName();
        BRepositoryBuilder repositoryBuilder(repository, name);

        if (Volume* volume = fRoot->GetVolume(repository.Location())) {
                for (PackageFileNameHashTable::Iterator it
                                = volume->PackagesByFileNameIterator(); it.HasNext();) {
                        Package* package = it.Next();
                        if (package->IsActive()) {
                                BSolverPackage* solverPackage;
                                repositoryBuilder.AddPackage(package->Info(), NULL,
                                        &solverPackage);
                                fSolverPackages[package] = solverPackage;
                        }
                }
        }
}


void
PackageManager::ResultComputed(InstalledRepository& repository)
{
        // Normalize the result, i.e. remove the packages added by the user which
        // have been removed again in the problem resolution process, and vice
        // versa.
        if (repository.Location() != fVolume->Location())
                return;

        PackageList& packagesToActivate = repository.PackagesToActivate();
        PackageList& packagesToDeactivate = repository.PackagesToDeactivate();

        for (int32 i = 0; BSolverPackage* package = packagesToDeactivate.ItemAt(i);
                i++) {
                if (fPackagesAddedByUser.erase(package) == 0)
                        continue;

                for (SolverPackageMap::iterator it = fSolverPackages.begin();
                        it != fSolverPackages.end(); ++it) {
                        if (it->second == package) {
                                fSolverPackages.erase(it);
                                break;
                        }
                }

                repository.EnablePackage(package);
                packagesToDeactivate.RemoveItemAt(i--);
                packagesToActivate.RemoveItem(package);
                repository.DeletePackage(package);
        }

        for (int32 i = 0; BSolverPackage* package = packagesToActivate.ItemAt(i);
                i++) {
                if (fPackagesRemovedByUser.erase(package) == 0)
                        continue;

                repository.EnablePackage(package);
                packagesToActivate.RemoveItemAt(i--);
                packagesToDeactivate.RemoveItem(package);

                // Note: We keep the package activated, but nonetheless it is gone,
                // since the user has removed it from the packages directory. So unless
                // the user moves it back, we won't find it upon next reboot.
                // TODO: We probable even run into trouble when the user moves in a
                // replacement afterward.
        }
}


status_t
PackageManager::PrepareTransaction(Transaction& transaction)
{
        Volume* volume = fRoot->GetVolume(transaction.Repository().Location());
        if (volume == NULL)
                return B_BAD_VALUE;

        return volume->CreateTransaction(transaction.Repository().Location(),
                transaction.ActivationTransaction(),
                transaction.TransactionDirectory());
}


status_t
PackageManager::CommitTransaction(Transaction& transaction,
        BCommitTransactionResult& _result)
{
        Volume* volume = fRoot->GetVolume(transaction.Repository().Location());
        if (volume == NULL)
                return B_BAD_VALUE;

        // Get the packages that have already been added to/removed from the
        // packages directory and thus need to be handled specially by
        // Volume::CommitTransaction().
        PackageSet packagesAlreadyAdded;
        PackageSet packagesAlreadyRemoved;
        if (volume == fVolume) {
                const PackageSet& packagesToActivate = volume->PackagesToBeActivated();
                for (PackageSet::const_iterator it = packagesToActivate.begin();
                        it != packagesToActivate.end(); ++it) {
                        Package* package = *it;
                        if (fPackagesAddedByUser.find(_SolverPackageFor(package))
                                        != fPackagesAddedByUser.end()) {
                                packagesAlreadyAdded.insert(package);
                        }
                }

                const PackageSet& packagesToDeactivate
                        = volume->PackagesToBeDeactivated();
                for (PackageSet::const_iterator it = packagesToDeactivate.begin();
                        it != packagesToDeactivate.end(); ++it) {
                        Package* package = *it;
                        if (fPackagesRemovedByUser.find(_SolverPackageFor(package))
                                        != fPackagesRemovedByUser.end()) {
                                packagesAlreadyRemoved.insert(package);
                        }
                }
        }

        volume->CommitTransaction(transaction.ActivationTransaction(),
                packagesAlreadyAdded, packagesAlreadyRemoved, _result);
        return B_OK;
}


void
PackageManager::HandleProblems()
{
        _InitGui();

        if (fProblemWindow == NULL)
                fProblemWindow = new ProblemWindow;

        if (!fProblemWindow->Go(fSolver, fPackagesAddedByUser,
                        fPackagesRemovedByUser)) {
                throw BAbortedByUserException();
        }
}


void
PackageManager::ConfirmChanges(bool fromMostSpecific)
{
        // Check whether there are any changes other than those made by the user.
        _InitGui();
        ResultWindow* window = new ResultWindow;
        ObjectDeleter<ResultWindow> windowDeleter(window);

        bool hasOtherChanges = false;
        int32 count = fInstalledRepositories.CountItems();
        if (fromMostSpecific) {
                for (int32 i = count - 1; i >= 0; i--)
                        hasOtherChanges
                                |= _AddResults(*fInstalledRepositories.ItemAt(i), window);
        } else {
                for (int32 i = 0; i < count; i++)
                        hasOtherChanges
                                |= _AddResults(*fInstalledRepositories.ItemAt(i), window);
        }

        if (!hasOtherChanges)
                return;

        // show the window
        if (windowDeleter.Detach()->Go() == 0)
                throw BAbortedByUserException();
}


void
PackageManager::Warn(status_t error, const char* format, ...)
{
        va_list args;
        va_start(args, format);
        BString message;
        message.SetToFormatVarArgs(format, args);
        va_end(args);

        if (error != B_OK)
                message << BString().SetToFormat(": %s", strerror(error));

        BNotification notification(B_ERROR_NOTIFICATION);
        notification.SetGroup(B_TRANSLATE("Package daemon"));
        notification.SetTitle(B_TRANSLATE("Warning"));
        notification.SetContent(message);
        notification.Send();
}


void
PackageManager::ProgressPackageDownloadStarted(const char* packageName)
{
}


void
PackageManager::ProgressPackageDownloadActive(const char* packageName,
        float completionPercentage, off_t bytes, off_t totalBytes)
{
}


void
PackageManager::ProgressPackageDownloadComplete(const char* packageName)
{
}


void
PackageManager::ProgressPackageChecksumStarted(const char* title)
{
}


void
PackageManager::ProgressPackageChecksumComplete(const char* title)
{
}


void
PackageManager::ProgressStartApplyingChanges(InstalledRepository& repository)
{
}


void
PackageManager::ProgressTransactionCommitted(InstalledRepository& repository,
        const BCommitTransactionResult& result)
{
}


void
PackageManager::ProgressApplyingChangesDone(InstalledRepository& repository)
{
}


void
PackageManager::JobFailed(BSupportKit::BJob* job)
{
// TODO:...
}


void
PackageManager::JobAborted(BSupportKit::BJob* job)
{
// TODO:...
}


bool
PackageManager::_AddResults(InstalledRepository& repository,
        ResultWindow* window)
{
        if (!repository.HasChanges())
                return false;

        return window->AddLocationChanges(repository.Name(),
                repository.PackagesToActivate(), fPackagesAddedByUser,
                repository.PackagesToDeactivate(), fPackagesRemovedByUser);
}


BSolverPackage*
PackageManager::_SolverPackageFor(Package* package) const
{
        SolverPackageMap::const_iterator it = fSolverPackages.find(package);
        return it != fSolverPackages.end() ? it->second : NULL;
}


void
PackageManager::_InitGui()
{
        BServer* server = dynamic_cast<BServer*>(be_app);
        if (server == NULL || server->InitGUIContext() != B_OK)
                throw BFatalErrorException("failed to initialize the GUI");
}