/*
 * Copyright 2012, Jérôme Duval, korli@users.berlios.de.
 * Copyright 2010, Michael Lotz, mmlr@mlotz.ch.
 * Copyright 2003, Tyler Dauwalder, tyler@dauwalder.net.
 * Distributed under the terms of the MIT License.
 */

#include "Icb.h"

#include "time.h"

#include "AllocationDescriptorList.h"
#include "Utils.h"
#include "Volume.h"

#include <file_cache.h>


status_t
DirectoryIterator::GetNextEntry(char *name, uint32 *length, ino_t *id)
{
	if (!id || !name || !length)
		return B_BAD_VALUE;

	TRACE(("DirectoryIterator::GetNextEntry: name = %p, length = %" B_PRIu32
		", id = %p, position = %" B_PRIdOFF ", parent length = %" B_PRIu64
		"\n", name, *length, id, fPosition, Parent()->Length()));

	status_t status = B_OK;
	if (fAtBeginning) {
		TRACE(("DirectoryIterator::GetNextEntry: .\n"));
		sprintf(name, ".");
		*length = 1;
		*id = Parent()->Id();
		fAtBeginning = false;
	} else {
		if (uint64(fPosition) >= Parent()->Length()) {
			TRACE(("DirectoryIterator::GetNextEntry: end of dir\n"));
			return B_ENTRY_NOT_FOUND;
		}

		uint8 data[kMaxFileIdSize];
		file_id_descriptor *entry = (file_id_descriptor *)data;

		uint32 block = 0;
		off_t offset = fPosition;

		size_t entryLength = kMaxFileIdSize;
		// First read in the static portion of the file id descriptor,
		// then, based on the information therein, read in the variable
		// length tail portion as well.
		status = Parent()->Read(offset, entry, &entryLength, &block);
		if (!status && entryLength >= sizeof(file_id_descriptor)
			&& entry->tag().init_check(block) == B_OK) {
			PDUMP(entry);
			offset += entry->total_length();

			if (entry->is_parent()) {
				TRACE(("DirectoryIterator::GetNextEntry: ..\n"));
				sprintf(name, "..");
				*length = 2;
			} else {
				UdfString string(entry->id(), entry->id_length());
				TRACE(("DirectoryIterator::GetNextEntry: UfdString id == `%s', "
					"length = %" B_PRIu32 "\n", string.Utf8(),
					string.Utf8Length()));
				DUMP(entry->icb());
				sprintf(name, "%s", string.Utf8());
				*length = string.Utf8Length();
			}
			*id = to_vnode_id(entry->icb());
		}

		if (!status)
			fPosition = offset;
	}

 	return status;
}


/*	\brief Rewinds the iterator to point to the first entry in the directory. */
void
DirectoryIterator::Rewind()
{
	fAtBeginning = true;
	fPosition = 0;
}


//	#pragma mark - Private methods


DirectoryIterator::DirectoryIterator(Icb *parent)
	:
	fAtBeginning(true),
	fParent(parent),
	fPosition(0)
{
}


Icb::Icb(Volume *volume, long_address address)
	:
	fVolume(volume),
	fData(volume),
	fInitStatus(B_NO_INIT),
	fId(to_vnode_id(address)),
	fPartition(address.partition()),
	fFileEntry(&fData),
	fExtendedEntry(&fData),
	fFileCache(NULL),
	fFileMap(NULL)
{
	TRACE(("Icb::Icb: volume = %p, address(block = %" B_PRIu32 ", partition = "
		"%d, length = %" B_PRIu32 ")\n", volume, address.block(),
		address.partition(), address.length()));

	if (volume == NULL) {
		fInitStatus = B_BAD_VALUE;
		return;
	}

	off_t block;
	status_t status = fVolume->MapBlock(address, &block);
	if (status == B_OK) {
		status = fData.SetTo(block);
		if (status == B_OK) {
			icb_header *header = (icb_header *)fData.Block();
			if (header->tag().id() == TAGID_FILE_ENTRY) {
				file_icb_entry *entry = (file_icb_entry *)header;
				PDUMP(entry);
				(void)entry;	// warning death
			} else if (header->tag().id() == TAGID_EXTENDED_FILE_ENTRY) {
				extended_file_icb_entry *entry
					= (extended_file_icb_entry *)header;
				PDUMP(entry);
				(void)entry;	// warning death
			} else {
				PDUMP(header);
			}
			status = header->tag().init_check(address.block());
		}
	}

	if (IsFile()) {
		fFileCache = file_cache_create(fVolume->ID(), fId, Length());
		fFileMap = file_map_create(fVolume->ID(), fId, Length());
	}

	fInitStatus = status;
	TRACE(("Icb::Icb: status = 0x%" B_PRIx32 ", `%s'\n", status,
		strerror(status)));
}


Icb::~Icb()
{
	if (fFileCache != NULL) {
		file_cache_delete(fFileCache);
		file_map_delete(fFileMap);
	}
}


status_t
Icb::GetDirectoryIterator(DirectoryIterator **iterator)
{
	status_t error = iterator ? B_OK : B_BAD_VALUE;

	if (!error) {
		*iterator = new(std::nothrow) DirectoryIterator(this);
		if (*iterator)
		 	fIteratorList.Add(*iterator);
		else
			error = B_NO_MEMORY;
	}

	return error;
}


status_t
Icb::InitCheck()
{
	return fInitStatus;
}


void
Icb::GetAccessTime(struct timespec &timespec) const
{
	timestamp ts;
	if (_Tag().id() == TAGID_EXTENDED_FILE_ENTRY)
		ts = _ExtendedEntry()->access_date_and_time();
	else
		ts = _FileEntry()->access_date_and_time();

	if (decode_time(ts, timespec) != B_OK) {
		decode_time(
			fVolume->PrimaryVolumeDescriptor()->recording_date_and_time(),
			timespec);
	}
}


void
Icb::GetModificationTime(struct timespec &timespec) const
{
	timestamp ts;
	if (_Tag().id() == TAGID_EXTENDED_FILE_ENTRY)
		ts = _ExtendedEntry()->modification_date_and_time();
	else
		ts = _FileEntry()->modification_date_and_time();

	if (decode_time(ts, timespec) != B_OK) {
		decode_time(
			fVolume->PrimaryVolumeDescriptor()->recording_date_and_time(),
			timespec);
	}
}


status_t
Icb::FindBlock(uint32 logicalBlock, off_t &block, bool &recorded)
{
	off_t pos = logicalBlock << fVolume->BlockShift();
	if (uint64(pos) >= Length()) {
		block = -1;
		return B_ERROR;
	}

	DEBUG_INIT_ETC("Icb", ("pos: %" B_PRIdOFF, pos));

	status_t status = B_OK;
	long_address extent;
	bool isEmpty = false;
	recorded = false;

	switch (_IcbTag().descriptor_flags()) {
		case ICB_DESCRIPTOR_TYPE_SHORT:
		{
			TRACE(("Icb::FindBlock: descriptor type -> short\n"));
			AllocationDescriptorList<ShortDescriptorAccessor> list(this,
				ShortDescriptorAccessor(fPartition));
			status = list.FindExtent(pos, &extent, &isEmpty);
			if (status != B_OK) {
				TRACE_ERROR(("Icb::FindBlock: error finding extent for offset "
					"%" B_PRIdOFF ". status = 0x%" B_PRIx32 " `%s'\n", pos, status,
					strerror(status)));
			}
			break;
		}

		case ICB_DESCRIPTOR_TYPE_LONG:
		{
			TRACE(("Icb::FindBlock: descriptor type -> long\n"));
			AllocationDescriptorList<LongDescriptorAccessor> list(this);
			status = list.FindExtent(pos, &extent, &isEmpty);
			if (status != B_OK) {
				TRACE_ERROR(("Icb::FindBlock: error finding extent for offset "
					"%" B_PRIdOFF ". status = 0x%" B_PRIx32 " `%s'\n", pos,
					status, strerror(status)));
			}
			break;
		}

		case ICB_DESCRIPTOR_TYPE_EXTENDED:
		{
			TRACE(("Icb::FindBlock: descriptor type -> extended\n"));
//			AllocationDescriptorList<ExtendedDescriptorAccessor> list(this, ExtendedDescriptorAccessor(0));
//			RETURN(_Read(list, pos, buffer, length, block));
			RETURN(B_ERROR);
			break;
		}

		case ICB_DESCRIPTOR_TYPE_EMBEDDED:
		{
			TRACE(("Icb::FindBlock: descriptor type: embedded\n"));
			RETURN(B_ERROR);
			break;
		}

		default:
			TRACE(("Icb::FindBlock: invalid icb descriptor flags! (flags = %d)\n",
				_IcbTag().descriptor_flags()));
			RETURN(B_BAD_VALUE);
			break;
	}

	if (status == B_OK) {
		block = extent.block();
		recorded = extent.type() == EXTENT_TYPE_RECORDED;
		TRACE(("Icb::FindBlock: block %" B_PRIdOFF "\n", block));
	}
	return status;
}


status_t
Icb::Read(off_t pos, void *buffer, size_t *length, uint32 *block)
{
	TRACE(("Icb::Read: pos = %" B_PRIdOFF ", buffer = %p, length = (%p)->%ld\n",
		pos, buffer, length, (length ? *length : 0)));

	DEBUG_INIT_ETC("Icb", ("pos: %" B_PRIdOFF " , length: %ld", pos, *length));

	if (fFileCache != NULL)
		return file_cache_read(fFileCache, NULL, pos, buffer, length);

	if (!buffer || !length || pos < 0)
		return B_BAD_VALUE;

	if (uint64(pos) >= Length()) {
		*length = 0;
		return B_OK;
	}

	switch (_IcbTag().descriptor_flags()) {
		case ICB_DESCRIPTOR_TYPE_SHORT:
		{
			TRACE(("Icb::Read: descriptor type -> short\n"));
			AllocationDescriptorList<ShortDescriptorAccessor> list(this,
				ShortDescriptorAccessor(fPartition));
			RETURN(_Read(list, pos, buffer, length, block));
			break;
		}

		case ICB_DESCRIPTOR_TYPE_LONG:
		{
			TRACE(("Icb::Read: descriptor type -> long\n"));
			AllocationDescriptorList<LongDescriptorAccessor> list(this);
			RETURN(_Read(list, pos, buffer, length, block));
			break;
		}

		case ICB_DESCRIPTOR_TYPE_EXTENDED:
		{
			TRACE(("Icb::Read: descriptor type -> extended\n"));
//			AllocationDescriptorList<ExtendedDescriptorAccessor> list(this, ExtendedDescriptorAccessor(0));
//			RETURN(_Read(list, pos, buffer, length, block));
			RETURN(B_ERROR);
			break;
		}

		case ICB_DESCRIPTOR_TYPE_EMBEDDED:
		{
			TRACE(("Icb::Read: descriptor type: embedded\n"));
			RETURN(B_ERROR);
			break;
		}

		default:
			TRACE(("Icb::Read: invalid icb descriptor flags! (flags = %d)\n",
				_IcbTag().descriptor_flags()));
			RETURN(B_BAD_VALUE);
			break;
	}
}


/*! \brief Does the dirty work of reading using the given DescriptorList object
	to access the allocation descriptors properly.
*/
template <class DescriptorList>
status_t
Icb::_Read(DescriptorList &list, off_t pos, void *_buffer, size_t *length, uint32 *block)
{
	TRACE(("Icb::_Read(): list = %p, pos = %" B_PRIdOFF ", buffer = %p, "
		"length = %ld\n", &list, pos, _buffer, (length ? *length : 0)));

	uint64 bytesLeftInFile = uint64(pos) > Length() ? 0 : Length() - pos;
	size_t bytesLeft = (*length >= bytesLeftInFile) ? bytesLeftInFile : *length;
	size_t bytesRead = 0;

	Volume *volume = GetVolume();
	status_t status = B_OK;
	uint8 *buffer = (uint8 *)_buffer;
	bool isFirstBlock = true;

	while (bytesLeft > 0) {

		TRACE(("Icb::_Read(): pos: %" B_PRIdOFF ", bytesLeft: %ld\n", pos,
			bytesLeft));
		long_address extent;
		bool isEmpty = false;
		status = list.FindExtent(pos, &extent, &isEmpty);
		if (status != B_OK) {
			TRACE_ERROR(("Icb::_Read: error finding extent for offset %"
				B_PRIdOFF ". status = 0x%" B_PRIx32 " `%s'\n", pos, status,
				strerror(status)));
			break;
		}

		TRACE(("Icb::_Read(): found extent for offset %" B_PRIdOFF ": (block: "
			"%" B_PRIu32 ", partition: %d, length: %" B_PRIu32 ", type: %d)\n",
			pos, extent.block(), extent.partition(), extent.length(),
			extent.type()));

		switch (extent.type()) {
			case EXTENT_TYPE_RECORDED:
				isEmpty = false;
				break;

			case EXTENT_TYPE_ALLOCATED:
			case EXTENT_TYPE_UNALLOCATED:
				isEmpty = true;
				break;

			default:
				TRACE_ERROR(("Icb::_Read(): Invalid extent type found: %d\n",
					extent.type()));
				status = B_ERROR;
				break;
		}

		if (status != B_OK)
			break;

		// Note the unmapped first block of the total read in
		// the block output parameter if provided
		if (isFirstBlock) {
			isFirstBlock = false;
			if (block)
				*block = extent.block();
		}

		off_t blockOffset
			= pos - off_t((pos >> volume->BlockShift()) << volume->BlockShift());

		size_t readLength = volume->BlockSize() - blockOffset;
		if (bytesLeft < readLength)
			readLength = bytesLeft;
		if (extent.length() < readLength)
			readLength = extent.length();

		TRACE(("Icb::_Read: reading block. offset = %" B_PRIdOFF
			", length: %ld\n", blockOffset, readLength));

		if (isEmpty) {
			TRACE(("Icb::_Read: reading %ld empty bytes as zeros\n",
				readLength));
			memset(buffer, 0, readLength);
		} else {
			off_t diskBlock;
			status = volume->MapBlock(extent, &diskBlock);
			if (status != B_OK) {
				TRACE_ERROR(("Icb::_Read: could not map extent\n"));
				break;
			}

			TRACE(("Icb::_Read: %ld bytes from disk block %" B_PRIdOFF " using"
				" block_cache_get_etc()\n", readLength, diskBlock));
			const uint8 *data;
			status = block_cache_get_etc(volume->BlockCache(),
				diskBlock, 0, readLength, (const void**)&data);
			if (status != B_OK)
				break;
			memcpy(buffer, data + blockOffset, readLength);
			block_cache_put(volume->BlockCache(), diskBlock);
		}

		bytesLeft -= readLength;
		bytesRead += readLength;
		pos += readLength;
		buffer += readLength;
	}

	*length = bytesRead;

	return status;
}


status_t
Icb::GetFileMap(off_t offset, size_t size, file_io_vec *vecs, size_t *count)
{
	switch (_IcbTag().descriptor_flags()) {
		case ICB_DESCRIPTOR_TYPE_SHORT:
		{
			AllocationDescriptorList<ShortDescriptorAccessor> list(this,
				ShortDescriptorAccessor(0));
			return _GetFileMap(list, offset, size, vecs, count);
		}

		case ICB_DESCRIPTOR_TYPE_LONG:
		{
			AllocationDescriptorList<LongDescriptorAccessor> list(this);
			return _GetFileMap(list, offset, size, vecs, count);
		}

		case ICB_DESCRIPTOR_TYPE_EXTENDED:
		case ICB_DESCRIPTOR_TYPE_EMBEDDED:
		default:
		{
			// TODO: implement?
			return B_UNSUPPORTED;
		}
	}
}


template<class DescriptorList>
status_t
Icb::_GetFileMap(DescriptorList &list, off_t offset, size_t size,
	struct file_io_vec *vecs, size_t *count)
{
	size_t index = 0;
	size_t max = *count;

	while (true) {
		long_address extent;
		bool isEmpty = false;
		status_t status = list.FindExtent(offset, &extent, &isEmpty);
		if (status != B_OK)
			return status;

		switch (extent.type()) {
			case EXTENT_TYPE_RECORDED:
				isEmpty = false;
				break;

			case EXTENT_TYPE_ALLOCATED:
			case EXTENT_TYPE_UNALLOCATED:
				isEmpty = true;
				break;

			default:
				return B_ERROR;
		}

		if (isEmpty)
			vecs[index].offset = -1;
		else {
			off_t diskBlock;
			fVolume->MapBlock(extent, &diskBlock);
			vecs[index].offset = diskBlock << fVolume->BlockShift();
		}

		off_t length = extent.length();
		vecs[index].length = length;

		offset += length;
		size -= length;
		index++;

		if (index >= max || (off_t)size <= vecs[index - 1].length
			|| offset >= (off_t)Length()) {
			*count = index;
			return index >= max ? B_BUFFER_OVERFLOW : B_OK;
		}
	}

	// can never get here
	return B_ERROR;
}


status_t
Icb::Find(const char *filename, ino_t *id)
{
	TRACE(("Icb::Find: filename = `%s', id = %p\n", filename, id));

	if (!filename || !id)
		return B_BAD_VALUE;

	DirectoryIterator *i;
	status_t status = GetDirectoryIterator(&i);
	if (status != B_OK)
		return status;

	ino_t entryId;
	uint32 length = B_FILE_NAME_LENGTH;
	char name[B_FILE_NAME_LENGTH];

	bool foundIt = false;
	while (i->GetNextEntry(name, &length, &entryId) == B_OK) {
		if (strcmp(filename, name) == 0) {
			foundIt = true;
			break;
		}

		// reset overwritten length
		length = B_FILE_NAME_LENGTH;
	}

	if (foundIt)
		*id = entryId;
	else
		status = B_ENTRY_NOT_FOUND;

	return status;
}