// ClientVolume.h

#ifndef NET_FS_CLIENT_VOLUME_H
#define NET_FS_CLIENT_VOLUME_H

#include <Locker.h>

#include "BlockingQueue.h"
#include "FSObject.h"
#include "HashString.h"
#include "Node.h"
#include "Permissions.h"
#include "ServerNodeID.h"

class AttrDirIterator;
class DirIterator;
class FileHandle;
class NodeInfo;
class NodeHandle;
class NodeHandleMap;
class NodeMonitoringEvent;
class QueryHandle;
class UserSecurityContext;
class Share;
class VolumeManager;

// ClientVolume
class ClientVolume : public FSObject, public BLocker {
public:
			class NodeMonitoringProcessor;

public:
								ClientVolume(Locker& securityContextLocker,
									NodeMonitoringProcessor*
										nodeMonitoringProcessor);
								~ClientVolume();

			status_t			Init();

			int32				GetID() const;

			status_t			Mount(UserSecurityContext* securityContext,
									Share* share);
			void				Unmount();
			bool				IsMounted() const;

			UserSecurityContext* GetSecurityContext() const;
			void				SetSecurityContext(
									UserSecurityContext* securityContext);

			Share*				GetShare() const;

			Directory*			GetRootDirectory() const;
			const NodeRef&		GetRootNodeRef() const;

			Permissions			GetSharePermissions() const;

			Permissions			GetNodePermissions(dev_t volumeID,
									ino_t nodeID);
			Permissions			GetNodePermissions(Node* node);

			Node*				GetNode(dev_t volumeID, ino_t nodeID);
			Node*				GetNode(NodeID nodeID);
			Node*				GetNode(const node_ref& nodeRef);

			Directory*			GetDirectory(dev_t volumeID, ino_t nodeID);
			Directory*			GetDirectory(NodeID nodeID);
			status_t			LoadDirectory(dev_t volumeID, ino_t nodeID,
									Directory** directory);

			Entry*				GetEntry(dev_t volumeID, ino_t dirID,
									const char* name);
			Entry*				GetEntry(Directory* directory,
									const char* name);
			status_t			LoadEntry(dev_t volumeID, ino_t dirID,
									const char* name, Entry** entry);
			status_t			LoadEntry(Directory* directory,
									const char* name, Entry** entry);

			status_t			Open(Node* node, int openMode,
									FileHandle** handle);
			status_t			OpenDir(Directory* directory,
									DirIterator** iterator);
			status_t			OpenAttrDir(Node* node,
									AttrDirIterator** iterator);
			status_t			Close(NodeHandle* handle);

			status_t			LockNodeHandle(int32 cookie,
									NodeHandle** handle);
			void				UnlockNodeHandle(NodeHandle* nodeHandle);

			void				ProcessNodeMonitoringEvent(
									NodeMonitoringEvent* event);

private:
	static	int32				_NextVolumeID();

private:
			struct NodeIDMap;
			struct NodeMap;

			int32				fID;
			UserSecurityContext* fSecurityContext;
			Locker&				fSecurityContextLock;
			NodeMonitoringProcessor* fNodeMonitoringProcessor;
			NodeHandleMap*		fNodeHandles;
			Share*				fShare;
			NodeRef				fRootNodeRef;
			Permissions			fSharePermissions;
			bool				fMounted;

	static	int32				sNextVolumeID;
};

// NodeMonitoringProcessor
class ClientVolume::NodeMonitoringProcessor {
public:
								NodeMonitoringProcessor() {}
	virtual						~NodeMonitoringProcessor();

	virtual	void				ProcessNodeMonitoringEvent(int32 volumeID,
									NodeMonitoringEvent* event) = 0;
};

// NodeHandleUnlocker
struct NodeHandleUnlocker {
	NodeHandleUnlocker(ClientVolume* volume, NodeHandle* nodeHandle)
		: fVolume(volume),
		  fHandle(nodeHandle)
	{
	}

	~NodeHandleUnlocker()
	{
		if (fVolume && fHandle) {
			fVolume->UnlockNodeHandle(fHandle);
			fVolume = NULL;
			fHandle = NULL;
		}
	}

private:
	ClientVolume*	fVolume;
	NodeHandle*		fHandle;
};

#endif	// NET_FS_CLIENT_VOLUME_H