/*
 * Copyright 2013, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold <ingo_weinhold@gmx.de>
 */
#ifndef ROOT_H
#define ROOT_H


#include <Locker.h>
#include <Node.h>
#include <ObjectList.h>
#include <OS.h>
#include <package/PackageDefs.h>
#include <String.h>

#include <Referenceable.h>

#include <package/packagefs.h>

#include "JobQueue.h"
#include "Volume.h"


class Root : public BReferenceable, private Volume::Listener {
public:
                                                                Root();
        virtual                                         ~Root();

                        status_t                        Init(const node_ref& nodeRef,
                                                                        bool isSystemRoot);

                        const node_ref&         NodeRef() const         { return fNodeRef; }
                        dev_t                           DeviceID() const        { return fNodeRef.device; }
                        ino_t                           NodeID() const          { return fNodeRef.node; }
                        const BString&          Path() const            { return fPath; }

                        bool                            IsSystemRoot() const
                                                                        { return fIsSystemRoot; }

                        status_t                        RegisterVolume(Volume* volume);
                        void                            UnregisterVolume(Volume* volume);
                                                                        // deletes the volume (eventually)

                        Volume*                         FindVolume(dev_t deviceID) const;
                        Volume*                         GetVolume(
                                                                        BPackageInstallationLocation location);

                        void                            HandleRequest(BMessage* message);

private:
        // Volume::Listener
        virtual void                            VolumeNodeMonitorEventOccurred(Volume* volume);

protected:
        virtual void                            LastReferenceReleased();

private:
                        struct AbstractVolumeJob;
                        struct VolumeJob;
                        struct ProcessNodeMonitorEventsJob;
                        struct CommitTransactionJob;
                        struct VolumeJobFilter;

                        friend struct CommitTransactionJob;

private:
                        Volume**                        _GetVolume(PackageFSMountType mountType);
                        Volume*                         _NextVolumeFor(Volume* volume);

                        void                            _InitPackages(Volume* volume);
                        void                            _DeleteVolume(Volume* volume);
                        void                            _ProcessNodeMonitorEvents(Volume* volume);
                        void                            _CommitTransaction(Volume* volume,
                                                                        BMessage* message);

                        status_t                        _QueueJob(Job* job);

        static  status_t                        _JobRunnerEntry(void* data);
                        status_t                        _JobRunner();

        static  void                            _ShowError(const char* errorMessage);

private:
        mutable BLocker                         fLock;
                        node_ref                        fNodeRef;
                        bool                            fIsSystemRoot;
                        BString                         fPath;
                        Volume*                         fSystemVolume;
                        Volume*                         fHomeVolume;
                        JobQueue                        fJobQueue;
                        thread_id                       fJobRunner;
};


#endif  // ROOT_H