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


#include <string.h>

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


struct driver_parameter;
class Directory;


namespace PackageFS {


class PackageSettingsItem {
public:
			class Entry {
			public:
				Entry(Entry* parent)
					:
					fParent(parent),
					fName(NULL),
					fIsBlocked(false),
					fHashNext(NULL)
				{
				}

				~Entry()
				{
					free(fName);
				}

				bool SetName(const char* name, size_t nameLength)
				{
					fName = (char*)malloc(nameLength + 1);
					if (fName == NULL)
						return false;

					memcpy(fName, name, nameLength);
					fName[nameLength] = '\0';
					return true;
				}

				Entry* Parent() const
				{
					return fParent;
				}

				const char* Name() const
				{
					return fName;
				}

				bool IsBlocked() const
				{
					return fIsBlocked;
				}

				void SetBlocked(bool blocked)
				{
					fIsBlocked = blocked;
				}

				Entry*& HashNext()
				{
					return fHashNext;
				}

			private:
				Entry*	fParent;
				char*	fName;
				bool	fIsBlocked;
				Entry*	fHashNext;
			};

			class EntryKey {
			public:
				EntryKey(Entry* parent, const char* name, size_t nameLength)
					:
					fParent(parent),
					fName(name),
					fNameLength(nameLength)
				{
				}

				EntryKey(Entry* parent, const char* name)
					:
					fParent(parent),
					fName(name),
					fNameLength(strlen(name))
				{
				}

				Entry* Parent() const
				{
					return fParent;
				}

				const char* Name() const
				{
					return fName;
				}

				size_t NameLength() const
				{
					return fNameLength;
				}

				size_t Hash() const
				{
					return (addr_t)fParent / 8
						^ hash_hash_string_part(fName, fNameLength);
				}

			private:
				Entry*		fParent;
				const char*	fName;
				size_t		fNameLength;
			};

public:
								PackageSettingsItem();
								~PackageSettingsItem();

	static	PackageSettingsItem* Load(::Directory* systemDirectory,
									const char* name);

			status_t			Init(const driver_parameter& parameter);

			void				AddEntry(Entry* entry);
			status_t			AddEntry(const char* path, Entry*& _entry);
			Entry*				FindEntry(Entry* parent, const char* name)
									const;
			Entry*				FindEntry(Entry* parent, const char* name,
									size_t nameLength) const;

			PackageSettingsItem*& HashNext()
									{ return fHashNext; }

private:
			struct EntryHashDefinition {
				typedef EntryKey	KeyType;
				typedef	Entry		ValueType;

				size_t HashKey(const EntryKey& key) const
				{
					return key.Hash();
				}

				size_t Hash(const Entry* value) const
				{
					return HashKey(EntryKey(value->Parent(), value->Name()));
				}

				bool Compare(const EntryKey& key, const Entry* value) const
				{
					const char* name = value->Name();
					return key.Parent() == value->Parent()
						&& strncmp(key.Name(), name, key.NameLength()) == 0
						&& name[key.NameLength()] == '\0';
				}

				Entry*& GetLink(Entry* value) const
				{
					return value->HashNext();
				}
			};

			typedef BOpenHashTable<EntryHashDefinition> EntryTable;

private:
			status_t			_AddBlockedEntries(
									const driver_parameter& parameter);

private:
			EntryTable			fEntries;
			PackageSettingsItem* fHashNext;
};


}	// namespace PackageFS


#endif	// BOOT_LOADER_FILE_SYSTEMS_PACKAGEFS_PACKAGE_SETTINGS_ITEM_H