/*
 * 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;
}