/*
 * Copyright 2009-2011, Michael Lotz, mmlr@mlotz.ch.
 * Distributed under the terms of the MIT License.
 */

#ifndef USERLAND_HID
#include "Driver.h"
#else
#include "UserlandHID.h"
#endif

#include "HIDReportItem.h"
#include "HIDReport.h"

#include <string.h>

HIDReportItem::HIDReportItem(HIDReport *report, uint32 bitOffset,
        uint8 bitLength, bool hasData, bool isArray, bool isRelative,
        uint32 minimum, uint32 maximum, uint32 usage)
        :       fReport(report),
                fByteOffset(bitOffset / 8),
                fShift(bitOffset % 8),
                fMask(~(0xffffffff << bitLength)),
                fBitCount(bitLength),
                fByteCount((fShift + fBitCount + 7) / 8),
                fHasData(hasData),
                fArray(isArray),
                fRelative(isRelative),
                fMinimum(minimum),
                fMaximum(maximum),
                fUsage(usage),
                fData(0),
                fValid(false)
{
}


uint16
HIDReportItem::UsagePage()
{
        usage_value value;
        value.u.extended = fUsage;
        return value.u.s.usage_page;
}


uint16
HIDReportItem::UsageID()
{
        usage_value value;
        value.u.extended = fUsage;
        return value.u.s.usage_id;
}


status_t
HIDReportItem::Extract()
{
        // The specs restrict items to span at most across 4 bytes, which means
        // that we can always just byte-align, copy four bytes and then shift and
        // mask as needed.
        uint8 *report = fReport->CurrentReport();
        if (report == NULL)
                return B_NO_INIT;

        memcpy(&fData, report + fByteOffset, fByteCount);
        fData >>= fShift;
        fData &= fMask;

        if (Signed()) {
                // sign extend if needed.
                if ((fData & ~(fMask >> 1)) != 0)
                        fData |= ~fMask;

                fValid = (int32)fData >= (int32)fMinimum
                        && (int32)fData <= (int32)fMaximum;
        } else
                fValid = fData >= fMinimum && fData <= fMaximum;

        return B_OK;
}


status_t
HIDReportItem::Insert()
{
        uint8 *report = fReport->CurrentReport();
        if (report == NULL)
                return B_NO_INIT;

        uint32 value;
        memcpy(&value, report + fByteOffset, fByteCount);
        value &= ~(fMask << fShift);

        if (fValid)
                value |= (fData & fMask) << fShift;

        memcpy(report + fByteOffset, &value, fByteCount);
        return B_OK;
}


status_t
HIDReportItem::SetData(uint32 data)
{
        fData = data;

        if (Signed()) {
                fValid = (int32)fData >= (int32)fMinimum
                        && (int32)fData <= (int32)fMaximum;
        } else
                fValid = fData >= fMinimum && fData <= fMaximum;

        return fValid ? B_OK : B_BAD_VALUE;
}


uint32
HIDReportItem::ScaledData(uint8 scaleToBits, bool toBeSigned)
{
        uint32 source;
        if (Signed() != toBeSigned) {
                if (toBeSigned)
                        source = (uint32)((int32)fData - (fMaximum + 1) / 2) & fMask;
                else
                        source = (uint32)((int32)fData - (int32)fMinimum);
        } else
                source = fData & fMask;

        if (fBitCount == scaleToBits)
                return source;

        int8 shift;
        uint32 result = 0;
        do {
                shift = scaleToBits - fBitCount;
                if (shift > 0) {
                        result |= source << shift;
                        scaleToBits = shift;
                } else
                        result |= source >> -shift;

        } while (shift > 0);

        return result;
}


uint32
HIDReportItem::ScaledRangeData(uint32 minimum, uint32 maximum)
{
        uint64 zeroBasedData;
        if (Signed())
                zeroBasedData = (int32)fData - (int32)fMinimum;
        else
                zeroBasedData = fData - fMinimum;

        return zeroBasedData * (maximum - minimum + 1) / (fMaximum - fMinimum + 1)
                + minimum;
}


float
HIDReportItem::ScaledFloatData()
{
        if (Signed()) {
                return (double)((int32)fData - (int32)fMinimum)
                        / (fMaximum - (int32)fMinimum);
        }

        return (double)(fData - fMinimum) / (fMaximum - fMinimum);
}


void
HIDReportItem::PrintToStream(uint32 indentLevel)
{
        char indent[indentLevel + 1];
        memset(indent, '\t', indentLevel);
        indent[indentLevel] = 0;

        TRACE_ALWAYS("%sHIDReportItem %p\n", indent, this);
        TRACE_ALWAYS("%s\tbyte offset: %" B_PRIu32 "\n", indent, fByteOffset);
        TRACE_ALWAYS("%s\tshift: %u\n", indent, fShift);
        TRACE_ALWAYS("%s\tmask: 0x%08" B_PRIx32 "\n", indent, fMask);
        TRACE_ALWAYS("%s\thas data: %s\n", indent, fHasData ? "yes" : "no");
        TRACE_ALWAYS("%s\tarray: %s\n", indent, fArray ? "yes" : "no");
        TRACE_ALWAYS("%s\trelative: %s\n", indent, fRelative ? "yes" : "no");
        TRACE_ALWAYS("%s\tminimum: %" B_PRIu32 "\n", indent, fMinimum);
        TRACE_ALWAYS("%s\tmaximum: %" B_PRIu32 "\n", indent, fMaximum);
        TRACE_ALWAYS("%s\tusage : 0x%08" B_PRIx32 "\n", indent, fUsage);

}