// ShareVolume.h

#ifndef NET_FS_SHARE_VOLUME_H
#define NET_FS_SHARE_VOLUME_H

#include <fsproto.h>

#include <util/DoublyLinkedList.h>

#include "EntryInfo.h"
#include "FSObject.h"
#include "Locker.h"
#include "RequestHandler.h"
#include "RequestMemberArray.h"
#include "ServerNodeID.h"
#include "Volume.h"

class AttrDirInfo;
class ExtendedServerInfo;
class ExtendedShareInfo;
class Node;
class ReadQueryReply;
class RemoteShareDirIterator;
class RequestConnection;
class RootShareVolume;
class ServerConnection;
class ServerConnectionProvider;
class ShareAttrDirIterator;
class ShareDir;
class ShareDirEntry;
class ShareNode;
class WalkReply;

class ShareVolume : public Volume {
public:
                                                                ShareVolume(VolumeManager* volumeManager,
                                                                        ServerConnectionProvider*
                                                                                connectionProvider,
                                                                        ExtendedServerInfo* serverInfo,
                                                                        ExtendedShareInfo* shareInfo);
                                                                ~ShareVolume();

                        int32                           GetID() const;

                        bool                            IsReadOnly() const;
                        bool                            SupportsQueries() const;

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

        virtual Node*                           GetRootNode() const;

        virtual void                            PrepareToUnmount();

        virtual void                            RemoveChildVolume(Volume* volume);

                        // FS
        virtual status_t                        Unmount();
        virtual status_t                        Sync();

                        // 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);

                        // 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
                        status_t                        GetQueryEntry(const EntryInfo& entryInfo,
                                                                        const NodeInfo& dirInfo,
                                                                        struct dirent* buffer, size_t bufferSize,
                                                                        int32* countRead);


                        // service methods called from "outside"
                        void                            ProcessNodeMonitoringRequest(
                                                                        NodeMonitoringRequest* request);
                        void                            ConnectionClosed();

private:
                        struct NodeMap;
                        struct EntryKey;
                        struct EntryMap;
                        struct LocalNodeIDMap;
                        struct RemoteNodeIDMap;
                        struct DirCookie;
                        struct AttrDirCookie;
                        struct AttrDirIteratorMap;

private:
                        status_t                        _ReadRemoteDir(ShareDir* directory,
                                                                        RemoteShareDirIterator* remoteIterator);

                        void                            _HandleEntryCreatedRequest(
                                                                        EntryCreatedRequest* request);
                        void                            _HandleEntryRemovedRequest(
                                                                        EntryRemovedRequest* request);
                        void                            _HandleEntryMovedRequest(
                                                                        EntryMovedRequest* request);
                        void                            _HandleStatChangedRequest(
                                                                        StatChangedRequest* request);
                        void                            _HandleAttributeChangedRequest(
                                                                        AttributeChangedRequest* request);

                        status_t                        _GetLocalNodeID(NodeID remoteID, ino_t* localID,
                                                                        bool enter);
                        status_t                        _GetRemoteNodeID(ino_t localID,
                                                                        NodeID* remoteID);
                        void                            _RemoveLocalNodeID(ino_t localID);

                        ShareNode*                      _GetNodeByLocalID(ino_t localID);
                        ShareNode*                      _GetNodeByRemoteID(NodeID remoteID);
                        status_t                        _LoadNode(const NodeInfo& nodeInfo,
                                                                        ShareNode** node);
                        status_t                        _UpdateNode(const NodeInfo& nodeInfo);

                        ShareDirEntry*          _GetEntryByLocalID(ino_t localDirID,
                                                                        const char* name);
                        ShareDirEntry*          _GetEntryByRemoteID(NodeID remoteDirID,
                                                                        const char* name);
                        status_t                        _LoadEntry(ShareDir* directory,
                                                                        const EntryInfo& entryInfo,
                                                                        ShareDirEntry** entry);
                        void                            _RemoveEntry(ShareDirEntry* entry);
                        bool                            _IsObsoleteEntryInfo(
                                                                        const EntryInfo& entryInfo);

                        status_t                        _AddAttrDirIterator(ShareNode* node,
                                                                        ShareAttrDirIterator* iterator);
                        void                            _RemoveAttrDirIterator(ShareNode* node,
                                                                        ShareAttrDirIterator* iterator);
                        status_t                        _LoadAttrDir(ShareNode* node,
                                                                        const AttrDirInfo& attrDirInfo);
                        status_t                        _UpdateAttrDir(NodeID remoteID,
                                                                        const AttrDirInfo& attrDirInfo);

                        void                            _NodeRemoved(NodeID remoteID);
                        void                            _EntryCreated(NodeID remoteDirID,
                                                                        const char* name,
                                                                        const EntryInfo* entryInfo, int64 revision);
                        void                            _EntryRemoved(NodeID remoteDirID,
                                                                        const char* name, int64 revision);
                        void                            _EntryMoved(NodeID remoteOldDirID,
                                                                        const char* oldName, NodeID remoteNewDirID,
                                                                        const char* name,
                                                                        const EntryInfo* entryInfo, int64 revision);

                        status_t                        _Walk(NodeID remoteDirID, const char* entryName,
                                                                        bool resolveLink, WalkReply** reply);
                        status_t                        _MultiWalk(
                                                                        RequestMemberArray<EntryInfo>& entryInfos,
                                                                        MultiWalkReply** reply);
                        status_t                        _Close(intptr_t cookie);

                        uint32                          _GetConnectionState();
                        bool                            _IsConnected();
                        bool                            _EnsureShareMounted();
                        status_t                        _MountShare();

private:
                        int32                           fID;
                        uint32                          fFlags;
                        Locker                          fMountLock;
                        ShareDir*                       fRootNode;
                        NodeMap*                        fNodes;                 // local ID -> ShareNode
                        EntryMap*                       fEntries;               // local ID, name -> ShareDirEntry
                        AttrDirIteratorMap*     fAttrDirIterators;
                                // local ID -> DoublyLinkedList<>
                        LocalNodeIDMap*         fLocalNodeIDs;  // remote ID -> local ID
                        RemoteNodeIDMap*        fRemoteNodeIDs; // local ID -> remote ID
                        ServerConnectionProvider* fServerConnectionProvider;
                        ExtendedServerInfo*     fServerInfo;
                        ExtendedShareInfo*      fShareInfo;
                        ServerConnection*       fServerConnection;
                        RequestConnection*      fConnection;
                        uint32                          fSharePermissions;
                        uint32                          fConnectionState;
};

#endif  // NET_FS_SHARE_VOLUME_H