/*
 * Copyright 2003-2013, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "Directory.h"
#include "Volume.h"
#include "File.h"

#include <StorageDefs.h>

#include <string.h>
#include <unistd.h>
#include <stdio.h>


using std::nothrow;


namespace FFS {


Directory::Directory(Volume &volume, int32 block)
	:
	fVolume(volume)
{
	void *data = malloc(volume.BlockSize());
	if (data == NULL)
		return;

	if (read_pos(volume.Device(), block * volume.BlockSize(), data, volume.BlockSize()) == volume.BlockSize())
		fNode.SetTo(data, volume.BlockSize());
}


Directory::Directory(Volume &volume, RootBlock &root)
	:
	fVolume(volume)
{
	fNode.SetTo(root.BlockData(), root.BlockSize());
}


Directory::~Directory()
{
	free(fNode.BlockData());
}


status_t
Directory::InitCheck()
{
	return fNode.ValidateCheckSum();
}


status_t
Directory::Open(void **_cookie, int mode)
{
	_inherited::Open(_cookie, mode);

	HashIterator *iterator = new(nothrow) HashIterator(fVolume.Device(), fNode);
	if (iterator == NULL)
		return B_NO_MEMORY;

	if (iterator->InitCheck() != B_OK) {
		delete iterator;
		return B_NO_MEMORY;
	}

	*_cookie = (void *)iterator;
	return B_OK;
}


status_t
Directory::Close(void *cookie)
{
	_inherited::Close(cookie);

	delete (HashIterator *)cookie;
	return B_OK;
}


Node*
Directory::LookupDontTraverse(const char* name)
{
	if (!strcmp(name, ".")) {
		Acquire();
		return this;
	}

	HashIterator iterator(fVolume.Device(), fNode);
	if (iterator.InitCheck() != B_OK)
		return NULL;

	iterator.Goto(fNode.HashIndexFor(fVolume.Type(), name));

	NodeBlock *node;
	int32 block;
	while ((node = iterator.GetNext(block)) != NULL) {
		char fileName[FFS_NAME_LENGTH];
		if (node->GetName(fileName, sizeof(fileName)) == B_OK
			&& !strcmp(name, fileName)) {
			if (node->IsFile())
				return new(nothrow) File(fVolume, block);
			if (node->IsDirectory())
				return new(nothrow) Directory(fVolume, block);

			return NULL;
		}
	}
	return NULL;
}


status_t
Directory::GetNextEntry(void *cookie, char *name, size_t size)
{
	HashIterator *iterator = (HashIterator *)cookie;
	int32 block;

	NodeBlock *node = iterator->GetNext(block);
	if (node == NULL)
		return B_ENTRY_NOT_FOUND;

	return node->GetName(name, size);
}


status_t
Directory::GetNextNode(void *cookie, Node **_node)
{
	return B_ERROR;
}


status_t
Directory::Rewind(void *cookie)
{
	HashIterator *iterator = (HashIterator *)cookie;
	iterator->Rewind();

	return B_OK;
}


bool
Directory::IsEmpty()
{
	int32 index;
	return fNode.FirstHashValue(index) == -1;
}


status_t
Directory::GetName(char *name, size_t size) const
{
	return fNode.GetName(name, size);
}


ino_t
Directory::Inode() const
{
	return fNode.HeaderKey();
}


}	// namespace FFS