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


#include <Referenceable.h>

#include <util/AutoLock.h>
#include <util/DoublyLinkedList.h>

#include <lock.h>

#include "DependencyFamily.h"
#include "ResolvableFamily.h"
#include "Volume.h"


class PackageLinksDirectory;


class PackageFSRoot : private BReferenceable,
        public DoublyLinkedListLinkImpl<PackageFSRoot> {
public:
        // constructor and destructor are conceptually private
                                                                PackageFSRoot(dev_t deviceID, ino_t nodeID);
        virtual                                         ~PackageFSRoot();

        static  status_t                        GlobalInit();
        static  void                            GlobalUninit();

        inline  bool                            ReadLock() const;
        inline  void                            ReadUnlock() const;
        inline  bool                            WriteLock();
        inline  void                            WriteUnlock();

                        status_t                        Init();

        static  status_t                        RegisterVolume(Volume* volume);
                        void                            UnregisterVolume(Volume* volume);

                        status_t                        AddPackage(Package* package);
                        void                            RemovePackage(Package* package);

                        dev_t                           DeviceID() const        { return fDeviceID; }
                        ino_t                           NodeID() const          { return fNodeID; }
                        bool                            IsCustom() const        { return fDeviceID < 0; }

                        Volume*                         SystemVolume() const;
                        PackageLinksDirectory* GetPackageLinksDirectory() const
                                                                        { return fPackageLinksDirectory; }

private:
                        typedef DoublyLinkedList<PackageFSRoot> RootList;
                        typedef DoublyLinkedList<Volume> VolumeList;

private:
                        status_t                        _AddVolume(Volume* volume);
                        void                            _RemoveVolume(Volume* volume);

                        status_t                        _AddPackage(Package* package);
                        void                            _RemovePackage(Package* package);

                        void                            _ResolveDependencies(
                                                                        ResolvableDependencyList& dependencies);
                        void                            _ResolveDependency(Dependency* dependency);

        static  status_t                        _GetOrCreateRoot(dev_t deviceID, ino_t nodeID,
                                                                        PackageFSRoot*& _root);
        static  PackageFSRoot*          _FindRootLocked(dev_t deviceID, ino_t nodeID);
        static  void                            _PutRoot(PackageFSRoot* root);

private:
        static  mutex                           sRootListLock;
        static  RootList                        sRootList;

        mutable rw_lock                         fLock;
                        dev_t                           fDeviceID;
                        ino_t                           fNodeID;
                        VolumeList                      fVolumes;
                        Volume*                         fSystemVolume;
                        PackageLinksDirectory* fPackageLinksDirectory;
                        ResolvableFamilyHashTable fResolvables;
                        DependencyFamilyHashTable fDependencies;
};


bool
PackageFSRoot::ReadLock() const
{
        return rw_lock_read_lock(&fLock) == B_OK;
}


void
PackageFSRoot::ReadUnlock() const
{
        rw_lock_read_unlock(&fLock);
}


bool
PackageFSRoot::WriteLock()
{
        return rw_lock_write_lock(&fLock) == B_OK;
}


void
PackageFSRoot::WriteUnlock()
{
        rw_lock_write_unlock(&fLock);
}


typedef AutoLocker<const PackageFSRoot,
        AutoLockerReadLocking<const PackageFSRoot> > PackageFSRootReadLocker;
typedef AutoLocker<PackageFSRoot, AutoLockerWriteLocking<PackageFSRoot> >
        PackageFSRootWriteLocker;


#endif  // PACKAGE_FS_ROOT_H