// SecurityContext.h

#ifndef NET_FS_SECURITY_CONTEXT_H
#define NET_FS_SECURITY_CONTEXT_H

#include <Archivable.h>
#include <HashString.h>
#include <Locker.h>
#include <Node.h>
#include <Referenceable.h>

#include "Permissions.h"
#include "Vector.h"

class UserSecurityContext;

// User
class User : public BReferenceable, public BArchivable {
public:
								User();
								User(BMessage* archive);
								~User();

	virtual	status_t			Archive(BMessage* archive,
									bool deep = true) const;
	static	BArchivable*		Instantiate(BMessage* archive);


			status_t			Init(const char* name, const char* password);
			status_t			InitCheck() const;

			status_t			Unarchive(const BMessage* archive);

			const char*			GetName() const;
			const char*			GetPassword() const;

private:
			HashString			fName;
			HashString			fPassword;
};

// Share
class Share : public BReferenceable, public BArchivable {
public:
								Share();
								Share(BMessage* archive);
								~Share();

	virtual	status_t			Archive(BMessage* archive,
									bool deep = true) const;
	static	BArchivable*		Instantiate(BMessage* archive);

			status_t			Init(const char* name, const node_ref& ref,
									const char* path = NULL);
			status_t			Init(const char* name, const char* path);
			status_t			InitCheck() const;

			status_t			Unarchive(const BMessage* archive);

			const char*			GetName() const;
			bool				DoesExist() const;
			const node_ref&		GetNodeRef() const;
			dev_t				GetVolumeID() const;
			ino_t				GetNodeID() const;
			const char*			GetPath() const;

private:
			HashString			fName;
			node_ref			fNodeRef;
			HashString			fPath;
};

// SecurityContext
class SecurityContext : public BArchivable, public BLocker {
public:
								SecurityContext();
								SecurityContext(BMessage* archive);
								~SecurityContext();

	virtual	status_t			Archive(BMessage* archive,
									bool deep = true) const;
	static	BArchivable*		Instantiate(BMessage* archive);

			status_t			InitCheck() const;

			status_t			AddUser(const char* name, const char* password,
									User** user = NULL);
			status_t			RemoveUser(const char* name,
									User** user = NULL);
			status_t			RemoveUser(User* user);
			User*				FindUser(const char* name);
			status_t			AuthenticateUser(const char* name,
									const char* password, User** user);
			int32				CountUsers();
			status_t			GetUsers(BMessage* users);

			status_t			AddShare(const char* name, const node_ref& ref,
									Share** share = NULL);
			status_t			AddShare(const char* name, const char* path,
									Share** share = NULL);
			status_t			RemoveShare(const char* name,
									Share** share = NULL);
			status_t			RemoveShare(Share* share);
			Share*				FindShare(const char* name);
			int32				CountShares();
			status_t			GetShares(BMessage* shares);

			status_t			SetNodePermissions(const node_ref& ref,
									User* user, Permissions permissions);
			status_t			SetNodePermissions(const char* path,
									User* user, Permissions permissions);
			void				ClearNodePermissions(const node_ref& ref,
									User* user = NULL);
			void				ClearNodePermissions(const char* path,
									User* user = NULL);
			Permissions			GetNodePermissions(const node_ref& ref,
									User* user);
			Permissions			GetNodePermissions(const char* path,
									User* user);

			status_t			GetUserSecurityContext(User* user,
									UserSecurityContext* userContext);

private:
			status_t			_AddNodePath(const char* path,
									node_ref* ref = NULL);
			status_t			_AddNodePath(const node_ref& ref,
									HashString* path = NULL);
			status_t			_EnterNodePath(const char* path,
									const node_ref& ref);
			bool				_GetNodeForPath(const char* path,
									node_ref* ref);

private:
			struct UserMap;
			struct ShareMap;
			struct UserPath;
			struct PermissionMap;
			struct NodePathMap;
			struct PathNodeMap;

			UserMap*			fUsers;
			ShareMap*			fShares;
			PermissionMap*		fPermissions;
			NodePathMap*		fNode2Path;
			PathNodeMap*		fPath2Node;
};

#endif	// NET_FS_SECURITY_CONTEXT_H