/*
 * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "bfs.h"

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


extern const char *__progname;
static const char *sProgramName = __progname;

static bool sDumpBlocks = false;


bool
disk_super_block::IsValid()
{
	if (Magic1() != (int32)SUPER_BLOCK_MAGIC1
		|| Magic2() != (int32)SUPER_BLOCK_MAGIC2
		|| Magic3() != (int32)SUPER_BLOCK_MAGIC3
		|| (int32)block_size != inode_size
		|| ByteOrder() != SUPER_BLOCK_FS_LENDIAN
		|| (1UL << BlockShift()) != BlockSize()
		|| AllocationGroups() < 1
		|| AllocationGroupShift() < 1
		|| BlocksPerAllocationGroup() < 1
		|| NumBlocks() < 10
		|| AllocationGroups() != divide_roundup(NumBlocks(),
			1L << AllocationGroupShift()))
		return false;

	return true;
}


off_t
toBlock(disk_super_block &superBlock, block_run run)
{
	return ((((off_t)run.AllocationGroup()) << superBlock.AllocationGroupShift()) | (off_t)run.Start());
}


off_t
toOffset(disk_super_block &superBlock, block_run run)
{
	return toBlock(superBlock, run) << superBlock.BlockShift();
}


void
dumpBlock(const char *buffer, int size)
{
	const int blockSize = 16;

	printf("\t");

	for (int i = 0; i < size;) {
		int start = i;

		for (; i < start + blockSize; i++) {
			if (!(i % 4))
				printf(" ");

			if (i >= size)
				printf("  ");
			else
				printf("%02x", *(unsigned char *)(buffer+i));
		}
		printf("  ");

		for (i = start; i < start + blockSize; i++) {
			if (i < size) {
				char c = *(buffer+i);

				if (c < 30)
					printf(".");
				else
					printf("%c", c);
			}
			else
				break;
		}

		if (i < size)
			printf("\n\t");
		else
			printf("\n");
	}
}


void
dumpLogEntry(int device, disk_super_block &superBlock, int32 &start, uint8 *block)
{
	int32 blockSize = superBlock.BlockSize();
	int32 entry = 0;
	off_t count = 1;
	int32 arrayBlocks = 1;
	off_t blockStart = start;
	bool first = true;
	int32 indexOffset = -1;
	int32 index = 0;
	off_t dataStart = blockStart;
	off_t bitmapSize = superBlock.AllocationGroups() * superBlock.BlocksPerAllocationGroup();

	uint8 *data = NULL;
	if (sDumpBlocks)
		data = (uint8 *)malloc(blockSize);

	for (int32 i = 0; i < arrayBlocks; i++) {
		off_t blockNumber = toBlock(superBlock, superBlock.log_blocks)
			+ blockStart++ % superBlock.log_blocks.Length();
		if (read_pos(device, blockNumber << superBlock.BlockShift(),
				block, blockSize) != blockSize) {
			fprintf(stderr, "%s: could not read block %lld.\n", sProgramName, blockNumber);
			exit(-1);
		}

		off_t *array = (off_t *)block;
		int32 arraySize = blockSize / sizeof(off_t);

		if (first) {
			count = array[0];
			arrayBlocks = ((count + 1) * sizeof(off_t) + blockSize - 1) / blockSize;
			arraySize--;
			dataStart += arrayBlocks;

			start += arrayBlocks + count;

			printf("Entry %ld contains %lld blocks (entry starts at block %lld):\n", entry, count, blockNumber);
			first = false;
		} else
			indexOffset += arraySize;

		for (; index < count; index++) {
			int32 arrayIndex = index - indexOffset;
			if (arrayIndex >= arraySize)
				break;

			off_t value = array[arrayIndex];
			printf("%7ld: %lld%s\n", index, value, value == 0 ? " (superblock)" :
				value < bitmapSize + 1 ? " (bitmap block)" : "");

			if (data != NULL) {
				off_t blockNumber = toBlock(superBlock, superBlock.log_blocks)
					+ ((dataStart + index) % superBlock.log_blocks.Length());
				if (read_pos(device, blockNumber << superBlock.BlockShift(),
						data, blockSize) != blockSize) {
					fprintf(stderr, "%s: could not read block %lld.\n", sProgramName, blockNumber);
				} else
					dumpBlock((char *)data, blockSize);
			}
		}
	}

	free(data);
}


void
usage(void)
{
	fprintf(stderr, "usage: %s [-d] bfs-volume\n"
		"    -d\tdump blocks in log\n", sProgramName);
	exit(0);
}


int
main(int argc, char **argv)
{
	if (argc < 2 || !strcmp(argv[1], "--help"))
		usage();

	while (*++argv) {
		char *arg = *argv;
		if (*arg == '-') {
			while (*++arg && isalpha(*arg)) {
				switch (*arg) {
					case 'd':
						sDumpBlocks = true;
						break;
					default:
						usage();
				}
			}
		}
		else
			break;
	}

	char *devicePath = argv[0];
	int device = open(devicePath, O_RDONLY);
	if (device < 0) {
		fprintf(stderr, "%s: could not open device %s: %s\n",
			sProgramName, devicePath, strerror(errno));
		return -1;
	}

	disk_super_block superBlock;
	if (read_pos(device, 512, &superBlock, sizeof(disk_super_block)) < (ssize_t)sizeof(disk_super_block)) {
		fprintf(stderr, "%s: could not read superblock.\n", sProgramName);
		return -1;
	}

	if (!superBlock.IsValid()) {
		fprintf(stderr, "%s: invalid superblock!\n", sProgramName);
		return -1;
	}

	if (superBlock.Flags() == SUPER_BLOCK_DISK_CLEAN) {
		printf("volume is clean; log is empty.\n");
		return 0;
	}

	off_t bitmapSize = superBlock.AllocationGroups() * superBlock.BlocksPerAllocationGroup();
	printf("Log area = (%lld - %lld), current start = %lld, end = %lld, %lld bitmap blocks\n",
		toBlock(superBlock, superBlock.log_blocks),
		toBlock(superBlock, superBlock.log_blocks) + superBlock.log_blocks.Length(),
		superBlock.LogStart(), superBlock.LogEnd(), bitmapSize);

	uint8 *block = (uint8 *)malloc(superBlock.BlockSize());
	if (block == NULL) {
		fprintf(stderr, "%s: could not allocate block!\n", sProgramName);
		return -1;
	}

	int32 start = superBlock.LogStart();
	int32 lastStart = -1;

	while (true) {
		if (start == superBlock.LogEnd())
			break;
		if (start == lastStart)
			break;

		lastStart = start;	
		dumpLogEntry(device, superBlock, start, block);
	}

	close(device);
	return 0;
}