/*
 * Copyright 2012, Jérôme Duval, korli@users.berlios.de.
 * Copyright 2003, Tyler Dauwalder, tyler@dauwalder.net.
 * Distributed under the terms of the MIT License.
 */

/*! \file Utils.cpp - Miscellaneous Udf utility functions. */

#include "UdfStructures.h"
#include "Utils.h"

extern "C" {
        extern int32 timezone_offset;
}

/*! \brief Returns "true" if \a value is true, "false" otherwise. */
const char*
bool_to_string(bool value)
{
        return value ? "true" : "false";
}


/*! \brief Calculates the UDF crc checksum for the given byte stream.

        Based on crc code from UDF-2.50 6.5, as permitted.

        \param data Pointer to the byte stream.
        \param length Length of the byte stream in bytes.

        \return The crc checksum, or 0 if an error occurred.
*/
uint16
calculate_crc(uint8 *data, uint16 length)
{
        uint16 crc = 0;
        if (data) {
                for ( ; length > 0; length--, data++)
                        crc = kCrcTable[(crc >> 8 ^ *data) & 0xff] ^ (crc << 8);
        }
        return crc;
}


/*! \brief Takes an overloaded ssize_t return value like those returned
        by BFile::Read() and friends, as well as an expected number of bytes,
        and returns B_OK if the byte counts match, or the appropriate error
        code otherwise.
*/
status_t
check_size_error(ssize_t bytesReturned, ssize_t bytesExpected)
{
        return bytesReturned == bytesExpected
                ? B_OK : (bytesReturned >= 0 ? B_IO_ERROR : status_t(bytesReturned));
}


/*! \brief Calculates the block shift amount for the given
        block size, which must be a positive power of 2.
*/
status_t
get_block_shift(uint32 blockSize, uint32 &blockShift)
{
        if (blockSize == 0)
                return B_BAD_VALUE;     
        uint32 bitCount = 0;
        uint32 result = 0;
        for (int i = 0; i < 32; i++) {
                // Zero out all bits except bit i
                uint32 block = blockSize & (uint32(1) << i);
                if (block) {
                        if (++bitCount > 1)
                                return B_BAD_VALUE;
                        else 
                                result = i;
                }
        }
        blockShift = result;
        return B_OK;
}


#define EPOCH_YEAR      1970
#define MAX_YEAR        69
#define SECSPERMIN      60
#define MINSPERHOUR     60
#define HOURSPERDAY     24
#define SECSPERDAY      (SECSPERMIN * MINSPERHOUR * HOURSPERDAY)
#define DAYSPERNYEAR    365

status_t
decode_time(timestamp &timestamp, struct timespec &timespec)
{
        DEBUG_INIT_ETC(NULL, ("timestamp: (tnt: 0x%x, type: %d, timezone: %d = 0x%x, year: %d, " 
                   "month: %d, day: %d, hour: %d, minute: %d, second: %d)", timestamp.type_and_timezone(),
                   timestamp.type(), timestamp.timezone(),
                    timestamp.timezone(),timestamp.year(),
                   timestamp.month(), timestamp.day(), timestamp.hour(), timestamp.minute(), timestamp.second()));

        if (timestamp.year() < EPOCH_YEAR || timestamp.year() >= EPOCH_YEAR + MAX_YEAR)
                return B_BAD_VALUE;

        time_t result = 0;
        const int monthLengths[12]
                = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

        int year = timestamp.year();
        int month = timestamp.month();
        int day = timestamp.day();
        int hour = timestamp.hour();
        int minute = timestamp.minute();
        int second = timestamp.second();

        // Range check the timezone offset, then round it down
        // to the nearest hour, since no one I know treats timezones
        // with a per-minute granularity, and none of the other OSes
        // I've looked at appear to either.
        int timezone_offset = 0;
        if (timestamp.type() == 1)
                timezone_offset = timestamp.timezone();
        if (-SECSPERDAY > timezone_offset || timezone_offset > SECSPERDAY)
                timezone_offset = 0;
        timezone_offset -= timezone_offset % 60;

        int previousLeapYears = (year - 1968) / 4;
        bool isLeapYear = (year - 1968) % 4 == 0;
        if (isLeapYear)
                --previousLeapYears;

        // Years to days
        result = (year - EPOCH_YEAR) * DAYSPERNYEAR + previousLeapYears;
        // Months to days
        for (int i = 0; i < month-1; i++) {
                result += monthLengths[i];
        }
        if (month > 2 && isLeapYear)
                ++result;
        // Days to hours
        result = (result + day - 1) * HOURSPERDAY;
        // Hours to minutes
        result = (result + hour) * MINSPERHOUR + timezone_offset;
        // Minutes to seconds
        result = (result + minute) * SECSPERMIN + second;

        timespec.tv_sec = result;
        timespec.tv_nsec = 1000 * (timestamp.microsecond()
                + timestamp.hundred_microsecond() * 100
                + timestamp.centisecond() * 10000);
        return B_OK;
}


long_address
to_long_address(ino_t id, uint32 length)
{
        TRACE(("udf_to_long_address: ino_t = %" B_PRIdINO ", length = %" B_PRIu32,
                id, length));
        long_address result;
        result.set_block((id >> 16) & 0xffffffff);
        result.set_partition(id & 0xffff);
        result.set_length(length);
        DUMP(result);
        return result;
}


ino_t
to_vnode_id(long_address address)
{
        DEBUG_INIT(NULL);
        ino_t result = address.block();
        result <<= 16;
        result |= address.partition();
        TRACE(("block:     %" B_PRIu32 ", 0x%" B_PRIx32 "\n", address.block(),
                address.block()));
        TRACE(("partition: %d, 0x%x\n", address.partition(), address.partition())); 
        TRACE(("length:    %" B_PRIu32 ", 0x%" B_PRIx32 "\n", address.length(),
                address.length()));
        TRACE(("ino_t:     %" B_PRIdINO "\n", result));
        return result;
}