// Volume.h

#ifndef NET_FS_VOLUME_H
#define NET_FS_VOLUME_H

#include <fsproto.h>

#include <HashString.h>

#include "FSObject.h"
#include "Locker.h"

class Node;
class QueryIterator;
class VolumeEvent;
class VolumeManager;

class Volume : public FSObject {
public:
                                                                Volume(VolumeManager* volumeManager);
                                                                ~Volume();

                        VolumeManager*          GetVolumeManager() const;

                        void                            SetParentVolume(Volume* parent);
                        Volume*                         GetParentVolume() const;
// TODO: Add the parent node ID and maybe get rid of parent volume.

                        void                            PutVolume();

                        status_t                        Init(const char* name);
                        void                            Uninit();

                        const char*                     GetName() const;

                        vnode_id                        GetRootID() const;
        virtual Node*                           GetRootNode() const = 0;

                        void                            SetUnmounting(bool unmounting);
                        bool                            IsUnmounting() const;

        virtual void                            PrepareToUnmount();

        virtual void                            RemoveChildVolume(Volume* volume) = 0;

        virtual void                            HandleEvent(VolumeEvent* event);

                        // client methods
                        status_t                        GetVNode(vnode_id vnid, Node** node);
                        status_t                        PutVNode(vnode_id vnid);
                        status_t                        NewVNode(vnode_id vnid, Node* node);
                        status_t                        RemoveVNode(vnode_id vnid);
                        status_t                        UnremoveVNode(vnode_id vnid);
                        int                                     IsVNodeRemoved(vnode_id vnid);

                        int                                     SendNotification(port_id port, int32 token,
                                                                        uint32 what, int32 op, nspace_id nsida,
                                                                        nspace_id nsidb, vnode_id vnida,
                                                                        vnode_id vnidb, vnode_id vnidc,
                                                                        const char *name);
                        int                                     NotifyListener(int32 opcode, nspace_id nsid,
                                                                        vnode_id vnida, vnode_id vnidb,
                                                                        vnode_id vnidc, const char *name);

                        // FS
        virtual status_t                        Unmount();
        virtual status_t                        Sync();
        virtual status_t                        ReadFSStat(fs_info* info);
        virtual status_t                        WriteFSStat(struct fs_info* info, int32 mask);

                        // vnodes
        virtual status_t                        ReadVNode(vnode_id vnid, char reenter,
                                                                        Node** node);
        virtual status_t                        WriteVNode(Node* node, char reenter);
        virtual status_t                        RemoveVNode(Node* node, char reenter);

                        // nodes
        virtual status_t                        FSync(Node* node);
        virtual status_t                        ReadStat(Node* node, struct stat* st);
        virtual status_t                        WriteStat(Node* node, struct stat *st,
                                                                        uint32 mask);
        virtual status_t                        Access(Node* node, int mode);

                        // files
        virtual status_t                        Create(Node* dir, const char* name,
                                                                        int openMode, int mode, vnode_id* vnid,
                                                                        void** cookie);
        virtual status_t                        Open(Node* node, int openMode,
                                                                        void** cookie);
        virtual status_t                        Close(Node* node, void* cookie);
        virtual status_t                        FreeCookie(Node* node, void* cookie);
        virtual status_t                        Read(Node* node, void* cookie, off_t pos,
                                                                        void* buffer, size_t bufferSize,
                                                                        size_t* bytesRead);
        virtual status_t                        Write(Node* node, void* cookie, off_t pos,
                                                                        const void* buffer, size_t bufferSize,
                                                                        size_t* bytesWritten);
        virtual status_t                        IOCtl(Node* node, void* cookie, int cmd,
                                                                        void* buffer, size_t bufferSize);
        virtual status_t                        SetFlags(Node* node, void* cookie,
                                                                        int flags);

                        // hard links / symlinks
        virtual status_t                        Link(Node* dir, const char* name,
                                                                        Node* node);
        virtual status_t                        Unlink(Node* dir, const char* name);
        virtual status_t                        Symlink(Node* dir, const char* name,
                                                                        const char* target);
        virtual status_t                        ReadLink(Node* node, char* buffer,
                                                                        size_t bufferSize, size_t* bytesRead);
        virtual status_t                        Rename(Node* oldDir, const char* oldName,
                                                                        Node* newDir, const char* newName);

                        // directories
        virtual status_t                        MkDir(Node* dir, const char* name,
                                                                        int mode);
        virtual status_t                        RmDir(Node* dir, const char* name);
        virtual status_t                        OpenDir(Node* node, void** cookie);
        virtual status_t                        CloseDir(Node* node, void* cookie);
        virtual status_t                        FreeDirCookie(Node* node, void* cookie);
        virtual status_t                        ReadDir(Node* node, void* cookie,
                                                                        struct dirent* buffer, size_t bufferSize,
                                                                        int32 count, int32* countRead);
        virtual status_t                        RewindDir(Node* node, void* cookie);
        virtual status_t                        Walk(Node* dir, const char* entryName,
                                                                        char** resolvedPath, vnode_id* vnid);

                        // attributes
        virtual status_t                        OpenAttrDir(Node* node, void** cookie);
        virtual status_t                        CloseAttrDir(Node* node, void* cookie);
        virtual status_t                        FreeAttrDirCookie(Node* node,
                                                                        void* cookie);
        virtual status_t                        ReadAttrDir(Node* node, void* cookie,
                                                                        struct dirent* buffer, size_t bufferSize,
                                                                        int32 count, int32* countRead);
        virtual status_t                        RewindAttrDir(Node* node, void* cookie);
        virtual status_t                        ReadAttr(Node* node, const char* name,
                                                                        int type, off_t pos, void* buffer,
                                                                        size_t bufferSize, size_t* bytesRead);
        virtual status_t                        WriteAttr(Node* node, const char* name,
                                                                        int type, off_t pos, const void* buffer,
                                                                        size_t bufferSize, size_t* bytesWritten);
        virtual status_t                        RemoveAttr(Node* node, const char* name);
        virtual status_t                        RenameAttr(Node* node,
                                                                        const char* oldName, const char* newName);
        virtual status_t                        StatAttr(Node* node, const char* name,
                                                                        struct attr_info* attrInfo);

                        // queries
        virtual status_t                        OpenQuery(const char* queryString,
                                                                        uint32 flags, port_id port, int32 token,
                                                                        QueryIterator** iterator);
        virtual void                            FreeQueryIterator(QueryIterator* iterator);
        virtual status_t                        ReadQuery(QueryIterator* iterator,
                                                                        struct dirent* buffer, size_t bufferSize,
                                                                        int32 count, int32* countRead);

protected:
                        Locker                          fLock;
                        VolumeManager*          fVolumeManager;
                        Volume*                         fParentVolume;
                        HashString                      fName;
                        bool                            fUnmounting;
};

#endif  // NET_FS_VOLUME_H