/*
 * Copyright 2003-2009, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "amiga_rdb.h"

#include <ByteOrder.h>
#include <KernelExport.h>
#include <disk_device_manager/ddm_modules.h>
#include <disk_device_types.h>
#ifdef _BOOT_MODE
#       include <boot/partitions.h>
#else
#       include <DiskDeviceTypes.h>
#endif
#include <util/kernel_cpp.h>

#include <unistd.h>
#include <string.h>


//#define TRACE_AMIGA_RDB
#ifdef TRACE_AMIGA_RDB
#       define TRACE(x) dprintf x
#else
#       define TRACE(x) ;
#endif


#define AMIGA_PARTITION_MODULE_NAME "partitioning_systems/amiga_rdb/v1"


template<typename Type> bool
validate_check_sum(Type *type)
{
        if (type->SummedLongs() != sizeof(*type) / sizeof(uint32))
                return false;

        // check checksum
        uint32 *longs = (uint32 *)type;
        uint32 sum = 0;
        for (uint32 i = 0; i < type->SummedLongs(); i++)
                sum += B_BENDIAN_TO_HOST_INT32(longs[i]);

#ifdef TRACE_AMIGA_RDB
        if (sum != 0)
                TRACE(("search_rdb: check sum is incorrect!\n"));
#endif

        return sum == 0;
}


#ifdef TRACE_AMIGA_RDB
static char *
get_tupel(uint32 id)
{
        static unsigned char tupel[5];

        tupel[0] = 0xff & (id >> 24);
        tupel[1] = 0xff & (id >> 16);
        tupel[2] = 0xff & (id >> 8);
        tupel[3] = 0xff & (id);
        tupel[4] = 0;
        for (int16 i = 0;i < 4;i++) {
                if (tupel[i] < ' ' || tupel[i] > 128)
                        tupel[i] = '.';
        }

        return (char *)tupel;
}
#endif


static status_t
get_next_partition(int fd, rigid_disk_block &rdb, uint32 &cookie,
        partition_block &partition)
{
        if (cookie == 0) {
                // first entry
                cookie = rdb.FirstPartition();
        } else if (cookie == 0xffffffff) {
                // last entry
                return B_ENTRY_NOT_FOUND;
        }

        ssize_t bytesRead = read_pos(fd, (off_t)cookie * rdb.BlockSize(),
                (void *)&partition, sizeof(partition_block));
        if (bytesRead < (ssize_t)sizeof(partition_block))
                return B_ERROR;

        // TODO: Should we retry with the next block if the following test fails, as
        // long as this we find partition_blocks within a reasonable range?

        if (partition.ID() != RDB_PARTITION_ID
                || !validate_check_sum<partition_block>(&partition))
                return B_BAD_DATA;

        cookie = partition.Next();
        return B_OK;
}


static bool
search_rdb(int fd, rigid_disk_block **_rdb)
{
        for (int32 sector = 0; sector < RDB_LOCATION_LIMIT; sector++) {
                uint8 buffer[512];
                ssize_t bytesRead = read_pos(fd, sector * 512, buffer, sizeof(buffer));
                if (bytesRead < (ssize_t)sizeof(buffer)) {
                        TRACE(("search_rdb: read error: %ld\n", bytesRead));
                        return false;
                }

                rigid_disk_block *rdb = (rigid_disk_block *)buffer;
                if (rdb->ID() == RDB_DISK_ID
                        && validate_check_sum<rigid_disk_block>(rdb)) {
                        // copy the RDB to a new piece of memory
                        rdb = new rigid_disk_block();
                        memcpy(rdb, buffer, sizeof(rigid_disk_block));

                        *_rdb = rdb;
                        return true;
                }
        }

        return false;
}


// #pragma mark - public module interface


static status_t
amiga_rdb_std_ops(int32 op, ...)
{
        switch (op) {
                case B_MODULE_INIT:
                case B_MODULE_UNINIT:
                        return B_OK;
        }

        return B_ERROR;
}


static float
amiga_rdb_identify_partition(int fd, partition_data *partition, void **_cookie)
{
        rigid_disk_block *rdb;
        if (!search_rdb(fd, &rdb))
                return B_ERROR;

        *_cookie = (void *)rdb;
        return 0.5f;
}


static status_t
amiga_rdb_scan_partition(int fd, partition_data *partition, void *_cookie)
{
        TRACE(("amiga_rdb_scan_partition(cookie = %p)\n", _cookie));

        rigid_disk_block &rdb = *(rigid_disk_block *)_cookie;

        partition->status = B_PARTITION_VALID;
        partition->flags |= B_PARTITION_PARTITIONING_SYSTEM
                                                | B_PARTITION_READ_ONLY;
        partition->content_size = partition->size;

        // scan all children

        partition_block partitionBlock;
        uint32 index = 0, cookie = 0;
        status_t status;

        while ((status = get_next_partition(fd, rdb, cookie, partitionBlock))
                        == B_OK) {
                disk_environment &environment
                        = *(disk_environment *)&partitionBlock.environment[0];
                TRACE(("amiga_rdb: file system: %s\n",
                        get_tupel(B_BENDIAN_TO_HOST_INT32(environment.dos_type))));

                if (environment.Start() + environment.Size()
                                > (uint64)partition->size) {
                        TRACE(("amiga_rdb: child partition exceeds existing space (%lld "
                                "bytes)\n", environment.Size()));
                        continue;
                }

                partition_data *child = create_child_partition(partition->id, index++,
                        partition->offset + environment.Start(), environment.Size(), -1);
                if (child == NULL) {
                        TRACE(("amiga_rdb: Creating child at index %ld failed\n",
                                index - 1));
                        return B_ERROR;
                }

                child->block_size = environment.BlockSize();
        }

        if (status == B_ENTRY_NOT_FOUND)
                return B_OK;

        return status;
}


static void
amiga_rdb_free_identify_partition_cookie(partition_data *partition,
        void *_cookie)
{
        delete (rigid_disk_block *)_cookie;
}


#ifndef _BOOT_MODE
static partition_module_info sAmigaPartitionModule = {
#else
partition_module_info gAmigaPartitionModule = {
#endif
        {
                AMIGA_PARTITION_MODULE_NAME,
                0,
                amiga_rdb_std_ops
        },
        "amiga",                                                        // short_name
        AMIGA_PARTITION_NAME,                           // pretty_name
        0,                                                                      // flags

        // scanning
        amiga_rdb_identify_partition,
        amiga_rdb_scan_partition,
        amiga_rdb_free_identify_partition_cookie,
        NULL,
};

#ifndef _BOOT_MODE
partition_module_info *modules[] = {
        &sAmigaPartitionModule,
        NULL
};
#endif