/*
**
** Copyright 2017, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/

#include <android/hardware/confirmationui/support/cbor.h>

namespace android {
namespace hardware {
namespace confirmationui {
namespace support {
namespace {

inline uint8_t getByte(const uint64_t& v, const uint8_t index) {
    return v >> (index * 8);
}

WriteState writeBytes(WriteState state, uint64_t value, uint8_t size) {
    auto pos = state.data_;
    if (!(state += size)) return state;
    switch (size) {
        case 8:
            *pos++ = getByte(value, 7);
            *pos++ = getByte(value, 6);
            *pos++ = getByte(value, 5);
            *pos++ = getByte(value, 4);
            [[fallthrough]];
        case 4:
            *pos++ = getByte(value, 3);
            *pos++ = getByte(value, 2);
            [[fallthrough]];
        case 2:
            *pos++ = getByte(value, 1);
            [[fallthrough]];
        case 1:
            *pos++ = value;
            break;
        default:
            state.error_ = Error::MALFORMED;
    }
    return state;
}

}  // anonymous namespace

WriteState writeHeader(WriteState wState, Type type, const uint64_t value) {
    if (!wState) return wState;
    uint8_t& header = *wState.data_;
    if (!++wState) return wState;
    header = static_cast<uint8_t>(type) << 5;
    if (value < 24) {
        header |= static_cast<uint8_t>(value);
    } else if (value < 0x100) {
        header |= 24;
        wState = writeBytes(wState, value, 1);
    } else if (value < 0x10000) {
        header |= 25;
        wState = writeBytes(wState, value, 2);
    } else if (value < 0x100000000) {
        header |= 26;
        wState = writeBytes(wState, value, 4);
    } else {
        header |= 27;
        wState = writeBytes(wState, value, 8);
    }
    return wState;
}

bool checkUTF8Copy(const char* begin, const char* const end, uint8_t* out) {
    uint32_t multi_byte_length = 0;
    while (begin != end) {
        if (multi_byte_length) {
            // parsing multi byte character - must start with 10xxxxxx
            --multi_byte_length;
            if ((*begin & 0xc0) != 0x80) return false;
        } else if (!((*begin) & 0x80)) {
            // 7bit character -> nothing to be done
        } else {
            // msb is set and we were not parsing a multi byte character
            // so this must be a header byte
            char c = *begin << 1;
            while (c & 0x80) {
                ++multi_byte_length;
                c <<= 1;
            }
            // headers of the form 10xxxxxx are not allowed
            if (multi_byte_length < 1) return false;
            // chars longer than 4 bytes are not allowed (multi_byte_length does not count the
            // header thus > 3
            if (multi_byte_length > 3) return false;
        }
        if (out) *out++ = *reinterpret_cast<const uint8_t*>(begin++);
    }
    // if the string ends in the middle of a multi byte char it is invalid
    if (multi_byte_length) return false;
    return true;
}

}  // namespace support
}  // namespace confirmationui
}  // namespace hardware
}  // namespace android