/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef USERLAND_FS_FUSE_ENTRY_H
#define USERLAND_FS_FUSE_ENTRY_H

#include <new>

#include <RWLockManager.h>

#include <util/DoublyLinkedList.h>
#include <util/OpenHashTable.h>

#include "String.h"

#include "fuse_api.h"


namespace UserlandFS {

struct FUSENode;


struct FUSEEntryRef {
	ino_t		parentID;
	const char*	name;

	FUSEEntryRef(ino_t parentID, const char* name)
		:
		parentID(parentID),
		name(name)
	{
	}
};


struct FUSEEntry : DoublyLinkedListLinkImpl<FUSEEntry> {
	FUSENode*	parent;
	char*		name;
	FUSENode*	node;
	FUSEEntry*	hashLink;

	FUSEEntry()
		:
		name(NULL)
	{
	}

	~FUSEEntry()
	{
		free(name);
	}


	static FUSEEntry* Create(FUSENode* parent, const char* name, FUSENode* node)
	{
		FUSEEntry* entry = new(std::nothrow) FUSEEntry;
		if (entry == NULL)
			return NULL;

		char* clonedName = strdup(name);
		if (clonedName == NULL) {
			delete entry;
			return NULL;
		}

		entry->parent = parent;
		entry->name = clonedName;
		entry->node = node;

		return entry;
	}
};


typedef DoublyLinkedList<FUSEEntry> FUSEEntryList;


struct FUSENode : RWLockable {
	ino_t			id;
	FUSEEntryList	entries;
	int				type;
	int32			refCount;
	int32			cacheCount;
	bool			dirty;
	FUSENode*		hashLink;

	FUSENode(ino_t id, int type)
		:
		id(id),
		type(type),
		refCount(1),
		cacheCount(0),
		dirty(false)
	{
	}

	FUSENode* Parent() const
	{
		FUSEEntry* entry = entries.Head();
		return entry != NULL ? entry->parent : NULL;
	}
};


struct FUSEEntryHashDefinition {
	typedef FUSEEntryRef	KeyType;
	typedef	FUSEEntry		ValueType;

	size_t HashKey(const FUSEEntryRef& key) const
		{ return ((uint32)key.parentID ^ (uint32)(key.parentID >> 32)) * 37
			+ string_hash(key.name); }
	size_t Hash(const FUSEEntry* value) const
		{ return HashKey(FUSEEntryRef(value->parent->id, value->name)); }
	bool Compare(const FUSEEntryRef& key, const FUSEEntry* value) const
		{ return value->parent->id == key.parentID
			&& strcmp(value->name, key.name) == 0; }
	FUSEEntry*& GetLink(FUSEEntry* value) const
		{ return value->hashLink; }
};


struct FUSENodeHashDefinition {
	typedef ino_t		KeyType;
	typedef	FUSENode	ValueType;

	size_t HashKey(ino_t key) const
		{ return (uint32)key ^ (uint32)(key >> 32); }
	size_t Hash(const FUSENode* value) const
		{ return HashKey(value->id); }
	bool Compare(ino_t key, const FUSENode* value) const
		{ return value->id == key; }
	FUSENode*& GetLink(FUSENode* value) const
		{ return value->hashLink; }
};


typedef BOpenHashTable<FUSEEntryHashDefinition> FUSEEntryTable;
typedef BOpenHashTable<FUSENodeHashDefinition> FUSENodeTable;


}	// namespace UserlandFS

using UserlandFS::FUSENode;


#endif	// USERLAND_FS_FUSE_ENTRY_H