/*
 * Copyright 2020 Suhel Mehta, mehtasuhel@gmail.com
 * Copyright 2008-2010, Axel Dörfler, axeld@pinc-software.de.
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include "Inode.h"
#include <string.h>


#define TRACE_UFS2
#ifdef TRACE_UFS2
#define TRACE(x...) dprintf("\33[34mufs2:\33[0m " x)
#else
#define TRACE(x...) ;
#endif
#define ERROR(x...) dprintf("\33[34mufs2:\33[0m " x)


Inode::Inode(Volume* volume, ino_t id)
	:
	fVolume(volume),
	fID(id),
	fCache(NULL),
	fMap(NULL)
{
	rw_lock_init(&fLock, "ufs2 inode");

	int fd = fVolume->Device();
	ufs2_super_block* superblock = (ufs2_super_block* )&fVolume->SuperBlock();
	int64_t fs_block = ino_to_fsba(superblock, id);
	int64_t offset_in_block = ino_to_fsbo(superblock, id);
	int64_t offset = fs_block * superblock->fs_fsize + offset_in_block * sizeof(fNode);

	if (read_pos(fd, offset, (void*)&fNode, sizeof(fNode)) != sizeof(fNode)) {
		ERROR("Inode::Inode(): IO Error\n");
		fInitStatus = B_IO_ERROR;
		return;
	}
	fInitStatus = B_OK;

	if (fInitStatus == B_OK) {
		if (!IsDirectory() && !IsSymLink()) {
			fCache = file_cache_create(fVolume->ID(), ID(), Size());
			fMap = file_map_create(fVolume->ID(), ID(), Size());
		}
	}
}


Inode::Inode(Volume* volume, ino_t id, const ufs2_inode& item)
	:
	fVolume(volume),
	fID(id),
	fCache(NULL),
	fMap(NULL),
	fInitStatus(B_OK),
	fNode(item)
{
	if (!IsDirectory() && !IsSymLink()) {
		fCache = file_cache_create(fVolume->ID(), ID(), Size());
		fMap = file_map_create(fVolume->ID(), ID(), Size());
	}
}


Inode::Inode(Volume* volume)
	:
	fVolume(volume),
	fID(0),
	fCache(NULL),
	fMap(NULL),
	fInitStatus(B_NO_INIT)
{
	rw_lock_init(&fLock, "ufs2 inode");
}


Inode::~Inode()
{
	TRACE("Inode destructor\n");
	file_cache_delete(FileCache());
	file_map_delete(Map());
	TRACE("Inode destructor: Done\n");
}


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


status_t
Inode::ReadAt(off_t file_offset, uint8* buffer, size_t* _length)
{
	int fd = fVolume->Device();
	ufs2_super_block super_block = fVolume->SuperBlock();
	int32_t blockSize = super_block.fs_bsize;
	off_t pos;
	int64_t size = Size();
	off_t startBlockNumber = file_offset / blockSize;
	off_t endBlockNumber = (file_offset + *_length) / blockSize;
	off_t blockOffset = file_offset % blockSize;
	ssize_t length = 0;
	if (size <= file_offset || size < 0 || file_offset < 0) {
		*_length = 0;
		return B_OK;
	}
	if ((int64_t) *_length > size - file_offset)
		*_length = size - file_offset;
	if (startBlockNumber != endBlockNumber) {
		ssize_t remainingLength = blockSize - blockOffset;
		for (; startBlockNumber <= endBlockNumber; startBlockNumber++) {
			//code for reading multiple blocks
			pos = FindBlock(startBlockNumber, blockOffset);
			if (remainingLength > (int64_t) *_length - length)
				remainingLength = *_length - length;
			length += read_pos(fd, pos, buffer + length, remainingLength);
			blockOffset = 0;
			remainingLength = *_length - length;
			remainingLength = blockSize;
		}
		*_length = length;
		return B_OK;
	}
	pos = FindBlock(startBlockNumber, blockOffset);
	length = read_pos(fd, pos, buffer, *_length);
	*_length = length;
	return B_OK;

}


off_t
Inode::FindBlock(off_t blockNumber, off_t blockOffset)
{
	int fd = fVolume->Device();
	ufs2_super_block super_block = fVolume->SuperBlock();
	int32_t blockSize = super_block.fs_bsize;
	int32_t fragmentSize = super_block.fs_fsize;
	off_t indirectOffset;
	int64_t directBlock;
	off_t numberOfBlockPointers = blockSize / 8;
	const off_t numberOfIndirectBlocks = numberOfBlockPointers;
	const off_t numberOfDoubleIndirectBlocks = numberOfBlockPointers
		* numberOfBlockPointers;
	if (blockNumber < 12) {
		// read from direct block
		return GetBlockPointer(blockNumber) * fragmentSize + blockOffset;

	} else if (blockNumber < numberOfIndirectBlocks + 12) {
		//read from indirect block
		blockNumber = blockNumber - 12;
		indirectOffset = GetIndirectBlockPointer() *
			fragmentSize + (8 * blockNumber);
		read_pos(fd, indirectOffset,
			(void*)&directBlock, sizeof(directBlock));

		return directBlock * fragmentSize + blockOffset;

	} else if (blockNumber < numberOfDoubleIndirectBlocks
			+ numberOfIndirectBlocks + 12) {
		// Data is in double indirect block
		// Subract the already read blocks
		blockNumber = blockNumber - numberOfBlockPointers - 12;
		// Calculate indirect block inside double indirect block
		off_t indirectBlockNumber = blockNumber / numberOfBlockPointers;
		indirectOffset = GetDoubleIndirectBlockPtr() *
			fragmentSize + (8 * indirectBlockNumber);

		int64_t indirectPointer;
		read_pos(fd, indirectOffset,
			(void*)&indirectPointer, sizeof(directBlock));

		indirectOffset = indirectPointer * fragmentSize
			+ (8 * (blockNumber % numberOfBlockPointers));

		read_pos(fd, indirectOffset,
			(void*)&directBlock, sizeof(directBlock));

		return directBlock * fragmentSize + blockOffset;

	} else if (blockNumber < (numberOfIndirectBlocks
				* numberOfDoubleIndirectBlocks)
				+ (numberOfDoubleIndirectBlocks + numberOfBlockPointers + 12)) {
		// Reading from triple indirect block
		blockNumber = blockNumber - numberOfDoubleIndirectBlocks
			- numberOfBlockPointers - 12;

		// Get double indirect block
		// Double indirect block no
		off_t indirectBlockNumber = blockNumber / numberOfDoubleIndirectBlocks;

		// offset to double indirect block ptr
		indirectOffset = GetTripleIndirectBlockPtr() *
			fragmentSize + (8 * indirectBlockNumber);

		int64_t indirectPointer;
		// Get the double indirect block ptr
		read_pos(fd, indirectOffset,
			(void*)&indirectPointer, sizeof(directBlock));

		// Get the indirect block
		// number of indirect block ptr
		indirectBlockNumber = blockNumber / numberOfBlockPointers;
		// Indirect block ptr offset
		indirectOffset = indirectPointer * fragmentSize
			+ (8 * indirectBlockNumber);

		read_pos(fd, indirectOffset,
			(void*)&indirectPointer, sizeof(directBlock));

		// Get direct block pointer
		indirectOffset = indirectPointer * fragmentSize
			+ (8 * (blockNumber % numberOfBlockPointers));

		read_pos(fd, indirectOffset,
			(void*)&directBlock, sizeof(directBlock));

		return directBlock * fragmentSize + blockOffset;
	}

	return B_BAD_VALUE;
}


status_t
Inode::ReadLink(char* buffer, size_t *_bufferSize)
{
	strlcpy(buffer, fNode.symlinkpath, *_bufferSize);
	return B_OK;
}


status_t
Inode::CheckPermissions(int accessMode) const
{
	// you never have write access to a read-only volume
	if ((accessMode & W_OK) != 0/* && fVolume->IsReadOnly()*/)
		return B_READ_ONLY_DEVICE;

	return check_access_permissions(accessMode, Mode(), (gid_t)GroupID(),
		(uid_t)UserID());
}