/*
 * Copyright 2003-2013, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2008, François Revol <revol@free.fr>
 * Distributed under the terms of the MIT License.
 */


#include "Volume.h"
#include "Directory.h"
#include "CachedBlock.h"

#include <boot/partitions.h>
#include <boot/platform.h>

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


//#define TRACE(x) dprintf x
#define TRACE(x) do {} while (0)


using namespace FATFS;
using std::nothrow;


Volume::Volume(boot::Partition *partition)
	:
	fCachedBlock(NULL),
	fRoot(NULL)
{
	TRACE(("%s()\n", __FUNCTION__));
	if ((fDevice = open_node(partition, O_RDONLY)) < B_OK)
		return;

	fCachedBlock = new(nothrow) CachedBlock(*this);
	if (fCachedBlock == NULL)
		return;

	uint8 *buf;
	/* = (char *)malloc(4096);
	if (buf == NULL)
		return;*/

	fBlockSize = partition->block_size;
	switch (fBlockSize) {
	case 0x200:
		fBlockShift = 9;
		break;
	case 0x400:
		fBlockShift = 10;
		break;
	case 0x800:
		fBlockShift = 11;
		break;
	default:
		goto err1;
	}
	TRACE(("%s: reading bootsector\n", __FUNCTION__));
	// read boot sector
	buf = fCachedBlock->SetTo(0);
	if (buf == NULL)
		goto err1;

	TRACE(("%s: checking signature\n", __FUNCTION__));
	// check the signature
	if (((buf[0x1fe] != 0x55) || (buf[0x1ff] != 0xaa)) && (buf[0x15] == 0xf8))
		goto err1;

	if (!memcmp(buf+3, "NTFS    ", 8) || !memcmp(buf+3, "HPFS    ", 8))
		goto err1;

	TRACE(("%s: signature ok\n", __FUNCTION__));
	fBytesPerSector = read16(buf,0xb);
	switch (fBytesPerSector) {
	case 0x200:
		fSectorShift = 9;
		break;
	case 0x400:
		fSectorShift = 10;
		break;
	case 0x800:
		fSectorShift = 11;
		break;
	default:
		goto err1;
	}
	TRACE(("%s: block shift %d\n", __FUNCTION__, fBlockShift));

	fSectorsPerCluster = buf[0xd];
	switch (fSectorsPerCluster) {
	case 1:	case 2:	case 4:	case 8:
	case 0x10:	case 0x20:	case 0x40:	case 0x80:
		break;
	default:
		goto err1;
	}
	TRACE(("%s: sect/cluster %d\n", __FUNCTION__, fSectorsPerCluster));
	fClusterShift = fSectorShift;
	for (uint32 spc = fSectorsPerCluster; !(spc & 0x01); ) {
		spc >>= 1;
		fClusterShift += 1;
	}
	TRACE(("%s: cluster shift %d\n", __FUNCTION__, fClusterShift));

	fReservedSectors = read16(buf,0xe);
	fFatCount = buf[0x10];
	if ((fFatCount == 0) || (fFatCount > 8))
		goto err1;

	fMediaDesc = buf[0x15];
	if ((fMediaDesc != 0xf0) && (fMediaDesc < 0xf8))
		goto err1;

	fSectorsPerFat = read16(buf,0x16);
	if (fSectorsPerFat == 0) {
		// FAT32
		fFatBits = 32;
		fSectorsPerFat = read32(buf,0x24);
		fTotalSectors = read32(buf,0x20);
		bool lFatMirrored = !(buf[0x28] & 0x80);
		fActiveFat = (lFatMirrored) ? (buf[0x28] & 0xf) : 0;
		fDataStart = fReservedSectors + fFatCount * fSectorsPerFat;
		fTotalClusters = (fTotalSectors - fDataStart) / fSectorsPerCluster;
		fRootDirCluster = read32(buf,0x2c);
		if (fRootDirCluster >= fTotalClusters)
			goto err1;

		fFSInfoSector = read16(buf, 0x30);
		if (fFSInfoSector < 1 || fFSInfoSector > fTotalSectors)
			goto err1;
	} else {
		// FAT12/16
		// XXX:FIXME
		fFatBits = 16;
		goto err1;
	}
	TRACE(("%s: block size %d, sector size %d, sectors/cluster %d\n",
		__FUNCTION__, fBlockSize, fBytesPerSector, fSectorsPerCluster));
	TRACE(("%s: block shift %d, sector shift %d, cluster shift %d\n",
		__FUNCTION__, fBlockShift, fSectorShift, fClusterShift));
	TRACE(("%s: reserved %d, max root entries %d, media %02x, sectors/fat %d\n",
		__FUNCTION__, fReservedSectors, fMaxRootEntries, fMediaDesc,
		fSectorsPerFat));

	//if (fTotalSectors > partition->sectors_per_track * partition->cylinder_count * partition->head_count)
	if ((off_t)fTotalSectors * fBytesPerSector > partition->size)
		goto err1;

	TRACE(("%s: found fat%d filesystem, root dir at cluster %d\n", __FUNCTION__,
		fFatBits, fRootDirCluster));

	fRoot = new(nothrow) Directory(*this, 0, fRootDirCluster, "/");
	return;

err1:
	TRACE(("fatfs: cannot mount (bad superblock ?)\n"));
	// XXX !? this triple-faults in QEMU ..
	//delete fCachedBlock;
}


Volume::~Volume()
{
	delete fRoot;
	delete fCachedBlock;
	close(fDevice);
}


status_t
Volume::InitCheck()
{
	if (fCachedBlock == NULL)
		return B_ERROR;
	if (fRoot == NULL)
		return B_ERROR;

	return B_OK;
}


status_t
Volume::GetName(char *name, size_t size) const
{
	//TODO: WRITEME
	return strlcpy(name, "UNKNOWN", size);
}


off_t
Volume::ClusterToOffset(uint32 cluster) const
{
	return (fDataStart << SectorShift()) + ((cluster - 2) << ClusterShift());
}

uint32
Volume::NextCluster(uint32 cluster, uint32 skip)
{
	//TRACE(("%s(%d, %d)\n", __FUNCTION__, cluster, skip));
	// lookup the FAT for next cluster in chain
	off_t offset;
	uint8 *buf;
	int32 next;
	int fatBytes = (FatBits() + 7) / 8;

	switch (fFatBits) {
		case 32:
		case 16:
			break;
		//XXX handle FAT12
		default:
			return InvalidClusterID();
	}

again:
	offset = fBytesPerSector * fReservedSectors;
	//offset += fActiveFat * fTotalClusters * fFatBits / 8;
	offset += cluster * fatBytes;

	if (!IsValidCluster(cluster))
		return InvalidClusterID();

	buf = fCachedBlock->SetTo(ToBlock(offset));
	if (!buf)
		return InvalidClusterID();

	offset %= BlockSize();

	switch (fFatBits) {
		case 32:
			next = read32(buf, offset);
			next &= 0x0fffffff;
			break;
		case 16:
			next = read16(buf, offset);
			break;
		default:
			return InvalidClusterID();
	}
	if (skip--) {
		cluster = next;
		goto again;
	}
	return next;
}


bool
Volume::IsValidCluster(uint32 cluster) const
{
	if (cluster > 1 && cluster < fTotalClusters)
		return true;
	return false;
}


bool
Volume::IsLastCluster(uint32 cluster) const
{
	if (cluster >= fTotalClusters && ((cluster & 0xff8) == 0xff8))
		return true;
	return false;
}


/*!	Allocates a free cluster.
	If \a previousCluster is a valid cluster idnex, its chain pointer is
	changed to point to the newly allocated cluster.
*/
status_t
Volume::AllocateCluster(uint32 previousCluster, uint32& _newCluster)
{
	if (fFatBits != 32)
		return B_UNSUPPORTED;
		// TODO: Support FAT16 and FAT12.

	const int fatBytes = FatBits() / 8;
	const uint32 blockOffsetMask = (uint32)BlockSize() - 1;

	// Iterate through the FAT to find a free cluster.
	off_t offset = fBytesPerSector * fReservedSectors;
	offset += 2 * fatBytes;
	for (uint32 i = 2; i < fTotalClusters; i++, offset += fatBytes) {
		uint8* buffer = fCachedBlock->SetTo(ToBlock(offset));
		if (buffer == NULL)
			return B_ERROR;

		uint32 value = read32(buffer, offset & blockOffsetMask);
		if (value == 0) {
			// found one -- mark it used (end of file)
			status_t error = _UpdateCluster(i, 0x0ffffff8);
			if (error != B_OK)
				return error;

			// If a previous cluster was given, update its list link.
			if (IsValidCluster(previousCluster)) {
				error = _UpdateCluster(previousCluster, i);
				if (error != B_OK) {
					_UpdateCluster(i, 0);
					return error;
				}
			}

			_ClusterAllocated(i);

			_newCluster = i;
			return B_OK;
		}
	}

	return B_DEVICE_FULL;
}


status_t
Volume::_UpdateCluster(uint32 cluster, uint32 value)
{
	if (fFatBits != 32 && fFatBits != 16)
		return B_UNSUPPORTED;
		// TODO: Support FAT12.

	if (!IsValidCluster(cluster))
		return InvalidClusterID();

	// get the buffer we need to change
	const int fatBytes = FatBits() / 8;

	for (uint8 i = 0; i < fFatCount; i++) {
		off_t offset
			= fBytesPerSector * (fReservedSectors + i * fSectorsPerFat);
		offset += cluster * fatBytes;

		uint8* buffer = fCachedBlock->SetTo(ToBlock(offset));
		if (buffer == NULL)
			return InvalidClusterID();

		offset %= BlockSize();

		// set the value
		switch (fFatBits) {
			case 32:
				*(uint32*)(buffer + offset) = B_HOST_TO_LENDIAN_INT32(value);
				break;
			case 16:
				*(uint16*)(buffer + offset) = B_HOST_TO_LENDIAN_INT16(value);
				break;
			default:
				return InvalidClusterID();
		}

		// write the block back to disk
		status_t error = fCachedBlock->Flush();
		if (error != B_OK) {
			fCachedBlock->Unset();
			return error;
		}
	}

	return B_OK;
}


status_t
Volume::_ClusterAllocated(uint32 cluster)
{
	// update the FS info

	// exists only for FAT32
	if (fFatBits != 32)
		return B_OK;

	off_t offset = fBytesPerSector * fFSInfoSector;

	status_t error = fCachedBlock->SetTo(offset / BlockSize(),
		CachedBlock::READ);
	if (error != B_OK)
		return error;

	uint8* buffer = fCachedBlock->Block() + offset % BlockSize();

	// update number of free cluster
	int32 freeClusters = read32(buffer, 0x1e8);
	if (freeClusters != -1)
		write32(buffer, 0x1e8, freeClusters - 1);

	// update number of most recently allocated cluster
	write32(buffer, 0x1ec, cluster);

	// write the block back
	error = fCachedBlock->Flush();
	if (error != B_OK)
		fCachedBlock->Unset();

	return error;
}


//	#pragma mark -


float
dosfs_identify_file_system(boot::Partition *partition)
{
	TRACE(("%s()\n", __FUNCTION__));
	Volume volume(partition);

	return volume.InitCheck() < B_OK ? 0 : 0.8;
}


static status_t
dosfs_get_file_system(boot::Partition *partition, ::Directory **_root)
{
	TRACE(("%s()\n", __FUNCTION__));
	Volume *volume = new(nothrow) Volume(partition);
	if (volume == NULL)
		return B_NO_MEMORY;

	if (volume->InitCheck() < B_OK) {
		delete volume;
		return B_ERROR;
	}

	*_root = volume->Root();
	return B_OK;
}


file_system_module_info gFATFileSystemModule = {
	"file_systems/dosfs/v1",
	kPartitionTypeFAT32, // XXX:FIXME: FAT16 too ?
	dosfs_identify_file_system,
	dosfs_get_file_system
};