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


#include "Index.h"
#include "Node.h"
#include "NodeListener.h"


class AbstractIndexIterator {
public:
								AbstractIndexIterator();
	virtual						~AbstractIndexIterator();

	virtual	bool				HasNext() const = 0;
	virtual Node*				Next(void* buffer, size_t* _keyLength) = 0;

	virtual	status_t			Suspend();
	virtual	status_t			Resume();
};


template<typename Policy>
class GenericIndexIterator : public AbstractIndexIterator,
	public NodeListener {
public:
			typedef typename Policy::Index		Index;
			typedef typename Policy::Value		Value;
			typedef typename Policy::NodeTree	NodeTree;
			typedef typename Policy::TreePolicy	TreePolicy;
			typedef typename NodeTree::Node		TreeNode;

public:
								GenericIndexIterator();
	virtual						~GenericIndexIterator();

	virtual	bool				HasNext() const;
	virtual	Node*				Next(void* buffer, size_t* _keyLength);

	virtual	status_t			Suspend();
	virtual	status_t			Resume();

			bool				SetTo(Index* index, const Value& name,
									bool ignoreValue = false);

	inline	void				NodeChangeBegin(Node* node);
	inline	void				NodeChangeEnd(Node* node);

	virtual void				NodeRemoved(Node* node);

protected:
			Index*				fIndex;
			TreeNode*			fNextTreeNode;
			bool				fSuspended;
};


template<typename Policy>
GenericIndexIterator<Policy>::GenericIndexIterator()
	:
	AbstractIndexIterator(),
	fIndex(NULL),
	fNextTreeNode(NULL),
	fSuspended(false)
{
}


template<typename Policy>
GenericIndexIterator<Policy>::~GenericIndexIterator()
{
	SetTo(NULL, Value());
}


template<typename Policy>
bool
GenericIndexIterator<Policy>::HasNext() const
{
	return fNextTreeNode != NULL;
}


template<typename Policy>
Node*
GenericIndexIterator<Policy>::Next(void* buffer, size_t* _keyLength)
{
	if (fSuspended || fNextTreeNode == NULL)
		return NULL;


	if (buffer != NULL)
		TreePolicy::GetTreeNodeValue(fNextTreeNode, buffer, _keyLength);

	TreeNode* treeNode = fNextTreeNode;
	fNextTreeNode = Policy::GetNodeTree(fIndex)->Next(fNextTreeNode);

	return TreePolicy::GetNode(treeNode);
}


template<typename Policy>
status_t
GenericIndexIterator<Policy>::Suspend()
{
	if (fSuspended)
		return B_BAD_VALUE;

	if (fNextTreeNode != NULL) {
		fIndex->GetVolume()->AddNodeListener(this,
			TreePolicy::GetNode(fNextTreeNode));
	}

	fSuspended = true;
	return B_OK;
}


template<typename Policy>
status_t
GenericIndexIterator<Policy>::Resume()
{
	if (!fSuspended)
		return B_BAD_VALUE;

	if (fNextTreeNode != NULL)
		fIndex->GetVolume()->RemoveNodeListener(this);

	fSuspended = false;
	return B_OK;
}


template<typename Policy>
bool
GenericIndexIterator<Policy>::SetTo(Index* index, const Value& value,
	bool ignoreValue)
{
	Resume();

	fIndex = index;
	fSuspended = false;
	fNextTreeNode = NULL;

	if (fIndex == NULL)
		return false;

	if (ignoreValue)
		fNextTreeNode = TreePolicy::GetFirstTreeNode(fIndex);
	else
		fNextTreeNode = TreePolicy::FindClosestTreeNode(fIndex, value);

	return fNextTreeNode != NULL;
}


/*!	Moves the iterator temporarily off the current node.
	Called when the node the iterator currently points to has been modified and
	the index is about to remove it from and reinsert it into the tree. After
	having done that NodeChangeEnd() must be called.
*/
template<typename Policy>
void
GenericIndexIterator<Policy>::NodeChangeBegin(Node* node)
{
	fNextTreeNode = Policy::GetNodeTree(fIndex)->Previous(fNextTreeNode);
}


/*!	Brackets a NodeChangeBegin() call.
*/
template<typename Policy>
void
GenericIndexIterator<Policy>::NodeChangeEnd(Node* node)
{
	if (fNextTreeNode != NULL)
		fNextTreeNode = Policy::GetNodeTree(fIndex)->Next(fNextTreeNode);
	else
		fNextTreeNode = TreePolicy::GetFirstTreeNode(fIndex);

	// If the node is no longer the one we originally pointed to, re-register
	// the node listener.
	if (fNextTreeNode == NULL) {
		fIndex->GetVolume()->RemoveNodeListener(this);
	} else {
		Node* newNode = TreePolicy::GetNode(fNextTreeNode);
		if (newNode != node) {
			fIndex->GetVolume()->RemoveNodeListener(this);
			fIndex->GetVolume()->AddNodeListener(this, newNode);
		}
	}
}


template<typename Policy>
void
GenericIndexIterator<Policy>::NodeRemoved(Node* node)
{
	Resume();
	Next(NULL, NULL);
	Suspend();
}


template<typename Policy>
struct GenericIndexIteratorTreePolicy {
	typedef typename Policy::Index		Index;
	typedef typename Policy::Value		Value;
	typedef typename Policy::NodeTree	NodeTree;
	typedef typename NodeTree::Node		TreeNode;

	static Node* GetNode(TreeNode* treeNode)
	{
		typename Policy::NodeTree::NodeStrategy strategy;
		return strategy.GetValue(treeNode);
	}

	static TreeNode* GetFirstTreeNode(Index* index)
	{
		typename NodeTree::Iterator iterator;
		Policy::GetNodeTree(index)->GetIterator(&iterator);
		return iterator.CurrentNode();
	}

	static TreeNode* FindClosestTreeNode(Index* index, const Value& value)
	{
		typename NodeTree::Iterator iterator;
		if (Policy::GetNodeTree(index)->FindFirstClosest(value, false,
				&iterator) == NULL) {
			return NULL;
		}

		return iterator.CurrentNode();
	}

	static void GetTreeNodeValue(TreeNode* treeNode, void* buffer,
		size_t* _keyLength)
	{
		Policy::GetNodeValue(GetNode(treeNode), buffer, _keyLength);
	}
};


#endif	// INDEX_IMPL_H