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


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

#include "StringKey.h"


struct driver_parameter;


class PackageSettingsItem {
public:
			class Entry {
			public:
				Entry(Entry* parent, const String& name)
					:
					fParent(parent),
					fName(name),
					fIsBlocked(false)
				{
				}

				Entry* Parent() const
				{
					return fParent;
				}

				const String& Name() const
				{
					return fName;
				}

				bool IsBlocked() const
				{
					return fIsBlocked;
				}

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

				Entry*& HashNext()
				{
					return fHashNext;
				}

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

			class EntryKey {
			public:
				EntryKey(Entry* parent, const char* name)
					:
					fParent(parent),
					fName(name),
					fHash((addr_t)parent / 8 ^ hash_hash_string(name))
				{
				}

				EntryKey(Entry* parent, const String& name)
					:
					fParent(parent),
					fName(name),
					fHash((addr_t)parent / 8 ^ name.Hash())
				{
				}

				Entry* Parent() const
				{
					return fParent;
				}

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

				size_t Hash() const
				{
					return fHash;
				}

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

public:
								PackageSettingsItem();
								~PackageSettingsItem();

			status_t			Init(const char* name);
			status_t			ApplySettings(
									const driver_parameter* parameters,
									int parameterCount);

			const String&		Name() const
									{ return fName; }

			void				AddEntry(Entry* entry);
			status_t			AddEntry(const char* path, Entry*& _entry);
			Entry*				FindEntry(Entry* parent, const String& name)
									const;
			Entry*				FindEntry(Entry* parent, const char* name)
									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
				{
					return key.Parent() == value->Parent()
						&& strcmp(key.Name(), value->Name()) == 0;
				}

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

			typedef BOpenHashTable<EntryHashDefinition> EntryTable;

private:
			status_t			_AddBlockedEntries(
									const driver_parameter& parameter);

private:
			String				fName;
			EntryTable			fEntries;
			PackageSettingsItem* fHashNext;
};


struct PackageSettingsItemHashDefinition {
	typedef StringKey			KeyType;
	typedef	PackageSettingsItem	ValueType;

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

	size_t Hash(const PackageSettingsItem* value) const
	{
		return HashKey(value->Name());
	}

	bool Compare(const StringKey& key, const PackageSettingsItem* value) const
	{
		return key == value->Name();
	}

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


class PackageSettings {
public:
								PackageSettings();
								~PackageSettings();

			status_t			Load(dev_t mountPointDeviceID,
									ino_t mountPointNodeID,
									PackageFSMountType mountType);

			const PackageSettingsItem* PackageItemFor(const String& name) const;

private:
			typedef BOpenHashTable<PackageSettingsItemHashDefinition>
				PackageItemTable;

private:
			status_t			_AddPackageSettingsItem(const char* name,
									const driver_parameter* parameters,
									int parameterCount);

private:
			PackageItemTable	fPackageItems;
};


#endif	// PACKAGE_SETTINGS_H