// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <endian.h>
#include <utf_conversion/utf_conversion.h>
#include <zircon/assert.h>

namespace {

enum class Endianness {
    HOST,
    INVERT,
};

#if BYTE_ORDER == BIG_ENDIAN
constexpr Endianness kBigEndian = Endianness::HOST;
constexpr Endianness kLittleEndian = Endianness::INVERT;
#else
constexpr Endianness kBigEndian = Endianness::INVERT;
constexpr Endianness kLittleEndian = Endianness::HOST;
#endif

template <Endianness E>
struct CodeUnit;

template <>
struct CodeUnit<Endianness::HOST> {
    static inline uint16_t Read(uint16_t val) { return val; }
};
template <>
struct CodeUnit<Endianness::INVERT> {
    static inline uint16_t Read(uint16_t val) { return __bswap16(val); }
};

static constexpr bool IsHighSurrogate(uint16_t val)  { return ((val >= 0xD800) && (val <= 0xDBFF)); }
static constexpr bool IsLowSurrogate(uint16_t val) { return ((val >= 0xDC00) && (val <= 0xDFFF)); }
constexpr uint32_t kMaxUnicodeCodePoint = 0x10FFFF;
constexpr uint32_t kSupplementaryPlaneStart = 0x10000;
constexpr uint32_t kUnicodeReplacementChar = 0xFFFD;

// If there is space to do so, encode the Unicode code point provided as UTF8.
// No matter what, return the number of bytes that the encoded code point would
// take.
//
// If the input is an invalid Unicode codepoint, signal this by returning 0.
inline uint32_t EncodeUtf8CodePoint(uint32_t code_point,
                                    uint8_t* tgt,
                                    size_t tgt_len,
                                    size_t offset) {
    // If this codepoint is illegal (for whatever reason), replace it with the
    // Unicode replacement character instead.
    if (code_point > kMaxUnicodeCodePoint) {
        code_point = kUnicodeReplacementChar;
    }

    if (code_point < 0x80) {
        if ((tgt_len > offset) && ((tgt_len - offset) >= 1)) {
            tgt[offset] = static_cast<uint8_t>(code_point);
        }
        return 1;
    } else
    if (code_point < 0x800) {
        if ((tgt_len > offset) && ((tgt_len - offset) >= 2)) {
            tgt[offset + 0] = static_cast<uint8_t>(0xC0 | (code_point >> 6));
            tgt[offset + 1] = static_cast<uint8_t>(0x80 | (code_point & 0x3F));
        }
        return 2;
    } else
    if (code_point < 0x10000) {
        if ((tgt_len > offset) && ((tgt_len - offset) >= 3)) {
            tgt[offset + 0] = static_cast<uint8_t>(0xE0 | (code_point >> 12));
            tgt[offset + 1] = static_cast<uint8_t>(0x80 | ((code_point >> 6) & 0x3F));
            tgt[offset + 2] = static_cast<uint8_t>(0x80 | (code_point & 0x3F));
        }
        return 3;
    }

    ZX_DEBUG_ASSERT(code_point <= kMaxUnicodeCodePoint);
    if ((tgt_len > offset) && ((tgt_len - offset) >= 4)) {
        tgt[offset + 0] = static_cast<uint8_t>(0xF0 | (code_point >> 18));
        tgt[offset + 1] = static_cast<uint8_t>(0x80 | ((code_point >> 12) & 0x3F));
        tgt[offset + 2] = static_cast<uint8_t>(0x80 | ((code_point >> 6) & 0x3F));
        tgt[offset + 3] = static_cast<uint8_t>(0x80 | (code_point & 0x3F));
    }
    return 4;
}

template <Endianness E>
zx_status_t Utf16ToUtf8(const uint16_t* src, size_t src_len, uint8_t* dst, size_t* dst_len,
                        uint32_t flags) {
    bool preserve_unpaired = (flags & UTF_CONVERT_FLAG_PRESERVE_UNPAIRED_SURROGATES);
    zx_status_t ret = ZX_OK;
    size_t rd = 0;
    size_t wr = 0;

    ZX_DEBUG_ASSERT((src != nullptr) && (dst_len != nullptr));
    ZX_DEBUG_ASSERT((dst != nullptr) || (*dst_len == 0));

    // Process all of our source characters.  Even if we run out of space in our
    // destination, we need to compute the space that we would have needed.
    while (rd < src_len) {
        uint16_t code_unit = CodeUnit<E>::Read(src[rd++]);
        uint32_t code_point;

        // If this is a high surrogate, go looking for its low surrogate pair.
        if (IsHighSurrogate(code_unit)) {
            uint16_t high = code_unit;

            // Fetch the next code unit, if any, and then attempt to pair it up
            // with this high surrogate.
            code_unit = (rd < src_len) ? CodeUnit<E>::Read(src[rd]) : 0;

            // If the next code unit we peeked at is a low surrogate, then
            // combine high and low to form the code point and then encode that.
            // Otherwise, the high surrogate we have encountered is unpaired and
            // should either be replaced or preserved, depending on our flags.
            if (IsLowSurrogate(code_unit)) {
                constexpr uint32_t SHIFT = 10u;
                constexpr uint32_t MASK = (1u << SHIFT) - 1;
                code_point = ((code_unit & MASK) | (static_cast<uint32_t>(high & MASK) << SHIFT))
                           + kSupplementaryPlaneStart;
                ++rd;
            } else {
                code_point = preserve_unpaired ? high : kUnicodeReplacementChar;
            }
        } else if (IsLowSurrogate(code_unit) && !preserve_unpaired) {
            code_point = kUnicodeReplacementChar;
        } else {
            code_point = code_unit;
        }

        wr += EncodeUtf8CodePoint(code_point, dst, *dst_len, wr);
    }


    *dst_len = wr;
    return ret;
}

}  // anon namespace

extern "C" {

zx_status_t utf16_to_utf8(const uint16_t* src, size_t src_len, uint8_t* dst, size_t *dst_len,
                          uint32_t flags) {
    // Sanity check our args.
    constexpr uint32_t ENDIAN_FLAGS = UTF_CONVERT_FLAG_FORCE_LITTLE_ENDIAN
                                    | UTF_CONVERT_FLAG_FORCE_BIG_ENDIAN;
    constexpr uint32_t ALL_FLAGS = UTF_CONVERT_FLAG_DISCARD_BOM |
                                   UTF_CONVERT_FLAG_PRESERVE_UNPAIRED_SURROGATES |
                                   ENDIAN_FLAGS;
    // dst_len *must* be provided, and all flags need to be understood.
    if ((dst_len == nullptr) || (flags & ~ALL_FLAGS)) {
        return ZX_ERR_INVALID_ARGS;
    }

    // dst may only be null if dst_len is zero (eg; a sizing operation)
    if ((dst == nullptr) && (*dst_len != 0)) {
        return ZX_ERR_INVALID_ARGS;
    }

    // handle the special case of an empty source string.
    if (!src || !src_len) {
        *dst_len = 0;
        return ZX_OK;
    }

    // Deal with endian detection.
    Endianness detected;

    constexpr uint16_t HOST_BOM = 0xFEFF;
    constexpr uint16_t INVERT_BOM = 0xFFFE;
    const uint16_t bom = *src;
    bool bom_detected = (bom == HOST_BOM) || (bom == INVERT_BOM);

    if ((flags & ENDIAN_FLAGS) == UTF_CONVERT_FLAG_FORCE_LITTLE_ENDIAN) {
        detected = kLittleEndian;
    } else
    if ((flags & ENDIAN_FLAGS) == UTF_CONVERT_FLAG_FORCE_BIG_ENDIAN) {
        detected = kBigEndian;
    } else {
        detected = (bom_detected && (bom == INVERT_BOM)) ? Endianness::INVERT : Endianness::HOST;
    }

    if (bom_detected && (flags & UTF_CONVERT_FLAG_DISCARD_BOM)) {
        ZX_DEBUG_ASSERT(src_len > 0);
        ++src;
        --src_len;
    }

    if (detected == Endianness::INVERT) {
        return Utf16ToUtf8<Endianness::INVERT>(src, src_len, dst, dst_len, flags);
    } else {
        return Utf16ToUtf8<Endianness::HOST>(src, src_len, dst, dst_len, flags);
    }
}

}  // extern "C"