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


#include "PackageFSRoot.h"

#include <AutoDeleterDrivers.h>

#include <vfs.h>

#include "DebugSupport.h"
#include "PackageLinksDirectory.h"
#include "StringConstants.h"


//#define TRACE_DEPENDENCIES_ENABLED
#ifdef TRACE_DEPENDENCIES_ENABLED
#       define TRACE_DEPENDENCIES(x...) TPRINT(x)
#else
#       define TRACE_DEPENDENCIES(x...) do {} while (false)
#endif


mutex PackageFSRoot::sRootListLock = MUTEX_INITIALIZER("packagefs root list");
PackageFSRoot::RootList PackageFSRoot::sRootList;


PackageFSRoot::PackageFSRoot(dev_t deviceID, ino_t nodeID)
        :
        fDeviceID(deviceID),
        fNodeID(nodeID),
        fSystemVolume(NULL),
        fPackageLinksDirectory(NULL)
{
        rw_lock_init(&fLock, "packagefs root");
}


PackageFSRoot::~PackageFSRoot()
{
        if (fPackageLinksDirectory != NULL)
                fPackageLinksDirectory->ReleaseReference();

        rw_lock_destroy(&fLock);
}


/*static*/ status_t
PackageFSRoot::GlobalInit()
{
        return B_OK;
}


/*static*/ void
PackageFSRoot::GlobalUninit()
{
}


status_t
PackageFSRoot::Init()
{
        // create package links directory
        fPackageLinksDirectory = new(std::nothrow) PackageLinksDirectory;
        if (fPackageLinksDirectory == NULL)
                return B_NO_MEMORY;

        status_t error = fPackageLinksDirectory->Init(
                StringConstants::Get().kPackageLinksDirectoryName);
        if (error != B_OK)
                RETURN_ERROR(error);

        error = fResolvables.Init();
        if (error != B_OK)
                RETURN_ERROR(error);

        error = fDependencies.Init();
        if (error != B_OK)
                RETURN_ERROR(error);

        return B_OK;
}


/*static*/ status_t
PackageFSRoot::RegisterVolume(Volume* volume)
{
        // Unless the volume is custom mounted, we stat the supposed root directory.
        // Get the volume mount point relative path to the root directory depending
        // on the mount type.
        const char* relativeRootPath = NULL;

        switch (volume->MountType()) {
                case PACKAGE_FS_MOUNT_TYPE_SYSTEM:
                        relativeRootPath = "..";
                        break;
                case PACKAGE_FS_MOUNT_TYPE_HOME:
                        relativeRootPath = "../..";
                        break;
                case PACKAGE_FS_MOUNT_TYPE_CUSTOM:
                default:
                        break;
        }

        if (relativeRootPath != NULL) {
                struct vnode* vnode;
                status_t error = vfs_entry_ref_to_vnode(volume->MountPointDeviceID(),
                        volume->MountPointNodeID(), relativeRootPath, &vnode);
                if (error != B_OK) {
                        dprintf("packagefs: Failed to get root directory \"%s\": %s\n",
                                relativeRootPath, strerror(error));
                        RETURN_ERROR(error);
                }
                VnodePutter vnodePutter(vnode);

                // stat it
                struct stat st;
                error = vfs_stat_vnode(vnode, &st);
                if (error != B_OK) {
                        dprintf("packagefs: Failed to stat root directory \"%s\": %s\n",
                                relativeRootPath, strerror(error));
                        RETURN_ERROR(error);
                }

                // get/create the root
                PackageFSRoot* root;
                error = PackageFSRoot::_GetOrCreateRoot(st.st_dev, st.st_ino, root);
                if (error != B_OK)
                        RETURN_ERROR(error);

                // add the volume
                error = root->_AddVolume(volume);
                if (error != B_OK) {
                        _PutRoot(root);
                        RETURN_ERROR(error);
                }

                return B_OK;
        }

        // custom mount -- always create a new root
        PackageFSRoot* root = new(std::nothrow) PackageFSRoot(-1, 0);
        if (root == NULL)
                return B_NO_MEMORY;
        ObjectDeleter<PackageFSRoot> rootDeleter(root);

        status_t error = root->Init();
        if (error != B_OK)
                RETURN_ERROR(error);

        // add the volume
        error = root->_AddVolume(volume);
        if (error != B_OK) {
                _PutRoot(root);
                RETURN_ERROR(error);
        }

        // We don't add the root to the list.
        rootDeleter.Detach();
        return B_OK;
}


void
PackageFSRoot::UnregisterVolume(Volume* volume)
{
        _RemoveVolume(volume);
        _PutRoot(this);
}


status_t
PackageFSRoot::AddPackage(Package* package)
{
        PackageFSRootWriteLocker writeLocker(this);

        status_t error = _AddPackage(package);
        if (error != B_OK) {
                _RemovePackage(package);
                RETURN_ERROR(error);
        }

        return B_OK;
}


void
PackageFSRoot::RemovePackage(Package* package)
{
        PackageFSRootWriteLocker writeLocker(this);

        _RemovePackage(package);
}


Volume*
PackageFSRoot::SystemVolume() const
{
        PackageFSRootReadLocker readLocker(this);
        return fSystemVolume;
}


status_t
PackageFSRoot::_AddVolume(Volume* volume)
{
        PackageFSRootWriteLocker writeLocker(this);

        volume->SetPackageFSRoot(this);

        fVolumes.Add(volume);
                // TODO: Correct order?

        if (fSystemVolume == NULL && volume->MountType()
                        == PACKAGE_FS_MOUNT_TYPE_SYSTEM) {
                fSystemVolume = volume;
        }

        return B_OK;
}


void
PackageFSRoot::_RemoveVolume(Volume* volume)
{
        PackageFSRootWriteLocker writeLocker(this);

        if (volume == fSystemVolume)
                fSystemVolume = NULL;

        fVolumes.Remove(volume);

        volume->SetPackageFSRoot(NULL);
}


status_t
PackageFSRoot::_AddPackage(Package* package)
{
        TRACE_DEPENDENCIES("adding package \"%s\"\n", package->Name().Data());

        ResolvableDependencyList dependenciesToUpdate;

        // register resolvables
        for (ResolvableList::ConstIterator it
                                = package->Resolvables().GetIterator();
                        Resolvable* resolvable = it.Next();) {
                TRACE_DEPENDENCIES("  adding resolvable \"%s\"\n",
                        resolvable->Name().Data());

                if (ResolvableFamily* family
                                = fResolvables.Lookup(resolvable->Name())) {
                        family->AddResolvable(resolvable, dependenciesToUpdate);
                } else {
                        family = new(std::nothrow) ResolvableFamily;
                        if (family == NULL)
                                return B_NO_MEMORY;

                        family->AddResolvable(resolvable, dependenciesToUpdate);
                        fResolvables.Insert(family);

                        // add pre-existing dependencies for that resolvable
                        if (DependencyFamily* dependencyFamily
                                        = fDependencies.Lookup(resolvable->Name())) {
                                dependencyFamily->AddDependenciesToList(dependenciesToUpdate);
                        }
                }
        }

        // register dependencies
        for (DependencyList::ConstIterator it
                                = package->Dependencies().GetIterator();
                        Dependency* dependency = it.Next();) {
                TRACE_DEPENDENCIES("  adding dependency \"%s\"\n",
                        dependency->Name().Data());

                if (DependencyFamily* family
                                = fDependencies.Lookup(dependency->Name())) {
                        family->AddDependency(dependency);
                } else {
                        family = new(std::nothrow) DependencyFamily;
                        if (family == NULL)
                                return B_NO_MEMORY;

                        family->AddDependency(dependency);
                        fDependencies.Insert(family);
                }

                dependenciesToUpdate.Add(dependency);
        }

        status_t error = fPackageLinksDirectory->AddPackage(package);
        if (error != B_OK)
                RETURN_ERROR(error);

        _ResolveDependencies(dependenciesToUpdate);

        return B_OK;
}


void
PackageFSRoot::_RemovePackage(Package* package)
{
        TRACE_DEPENDENCIES("removing package \"%s\"\n", package->Name().Data());

        fPackageLinksDirectory->RemovePackage(package);

        // unregister dependencies
        for (DependencyList::ConstIterator it
                                = package->Dependencies().GetIterator();
                        Dependency* dependency = it.Next();) {
                if (DependencyFamily* family = dependency->Family()) {
                        TRACE_DEPENDENCIES("  removing dependency \"%s\"\n",
                                dependency->Name().Data());

                        if (family->IsLastDependency(dependency)) {
                                fDependencies.Remove(family);
                                family->RemoveDependency(dependency);
                                delete family;
                        } else
                                family->RemoveDependency(dependency);
                }

                if (Resolvable* resolvable = dependency->Resolvable())
                        resolvable->RemoveDependency(dependency);
        }

        // unregister resolvables
        ResolvableDependencyList dependenciesToUpdate;

        for (ResolvableList::ConstIterator it
                                = package->Resolvables().GetIterator();
                        Resolvable* resolvable = it.Next();) {
                if (ResolvableFamily* family = resolvable->Family()) {
                        TRACE_DEPENDENCIES("  removing resolvable \"%s\"\n",
                                resolvable->Name().Data());

                        if (family->IsLastResolvable(resolvable)) {
                                fResolvables.Remove(family);
                                family->RemoveResolvable(resolvable, dependenciesToUpdate);
                                delete family;
                        } else
                                family->RemoveResolvable(resolvable, dependenciesToUpdate);
                }
        }

        _ResolveDependencies(dependenciesToUpdate);
}


void
PackageFSRoot::_ResolveDependencies(ResolvableDependencyList& dependencies)
{
        if (dependencies.IsEmpty())
                return;

        while (Dependency* dependency = dependencies.RemoveHead()) {
                Package* package = dependency->Package();
                _ResolveDependency(dependency);

                // also resolve all other dependencies for that package
                for (ResolvableDependencyList::Iterator it = dependencies.GetIterator();
                                (dependency = it.Next()) != NULL;) {
                        if (dependency->Package() == package) {
                                it.Remove();
                                _ResolveDependency(dependency);
                        }
                }

                fPackageLinksDirectory->UpdatePackageDependencies(package);
        }
}


void
PackageFSRoot::_ResolveDependency(Dependency* dependency)
{
        TRACE_DEPENDENCIES("  resolving dependency \"%s\" (package \"%s\")\n",
                dependency->Name().Data(), dependency->Package()->Name().Data());

        // get the resolvable family for the dependency
        ResolvableFamily* resolvableFamily
                = fResolvables.Lookup(dependency->Name());
        if (resolvableFamily == NULL) {
                TRACE_DEPENDENCIES("    -> dependency \"%s\" unresolved\n",
                        dependency->Name().Data());
                return;
        }

        // let the family resolve the dependency
        if (!resolvableFamily->ResolveDependency(dependency)) {
                TRACE_DEPENDENCIES("    -> dependency \"%s\" unresolved (version "
                        "mismatch)\n", dependency->Name().Data());
        }
}


/*static*/ status_t
PackageFSRoot::_GetOrCreateRoot(dev_t deviceID, ino_t nodeID,
        PackageFSRoot*& _root)
{
        // first check the list, if the root already exists
        MutexLocker rootListLocker(sRootListLock);

        if (PackageFSRoot* root = _FindRootLocked(deviceID, nodeID)) {
                root->AcquireReference();
                _root = root;
                return B_OK;
        }

        rootListLocker.Unlock();

        // create a new root
        PackageFSRoot* root = new(std::nothrow) PackageFSRoot(deviceID, nodeID);
        if (root == NULL)
                return B_NO_MEMORY;
        ObjectDeleter<PackageFSRoot> rootDeleter(root);

        status_t error = root->Init();
        if (error != B_OK)
                RETURN_ERROR(error);

        // add the root -- first recheck whether someone else added the root in the
        // meantime
        rootListLocker.Lock();

        if (PackageFSRoot* otherRoot = _FindRootLocked(deviceID, nodeID)) {
                // indeed, someone was faster
                otherRoot->AcquireReference();
                _root = otherRoot;
                return B_OK;
        }

        sRootList.Add(root);

        _root = rootDeleter.Detach();
        return B_OK;
}


/*static*/ PackageFSRoot*
PackageFSRoot::_FindRootLocked(dev_t deviceID, ino_t nodeID)
{
        for (RootList::Iterator it = sRootList.GetIterator();
                        PackageFSRoot* root = it.Next();) {
                if (root->DeviceID() == deviceID && root->NodeID() == nodeID)
                        return root;
        }

        return NULL;
}


/*static*/ void
PackageFSRoot::_PutRoot(PackageFSRoot* root)
{
        // Only non-custom roots are in the global list.
        if (!root->IsCustom()) {
                MutexLocker rootListLocker(sRootListLock);

                // When releasing the last reference, remove the root from the list.
                if (root->CountReferences() == 1)
                        sRootList.Remove(root);

                rootListLocker.Unlock();
        }

        root->ReleaseReference();
}