// © 2017 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "formatted_string_builder.h"

#include "unicode/ustring.h"

#include "unicode/utf16.h"

#include "unicode/unum.h" // for UNumberFormatFields literals

namespace {

// A version of uprv_memcpy that checks for length 0.

// By default, uprv_memcpy requires a length of at least 1.

inline void uprv_memcpy2(void* dest, const void* src, size_t len) {

    if (len > 0) {

        uprv_memcpy(dest, src, len);

    }

}

// A version of uprv_memmove that checks for length 0.

// By default, uprv_memmove requires a length of at least 1.

inline void uprv_memmove2(void* dest, const void* src, size_t len) {

    if (len > 0) {

        uprv_memmove(dest, src, len);

    }

}

} // namespace

U_NAMESPACE_BEGIN

FormattedStringBuilder::FormattedStringBuilder() {

#if U_DEBUG

    // Initializing the memory to non-zero helps catch some bugs that involve

    // reading from an improperly terminated string.

    for (int32_t i=0; i<getCapacity(); i++) {

        getCharPtr()[i] = 1;

    }

#endif

}

FormattedStringBuilder::~FormattedStringBuilder() {

    if (fUsingHeap) {

        uprv_free(fChars.heap.ptr);

        uprv_free(fFields.heap.ptr);

    }

}

FormattedStringBuilder::FormattedStringBuilder(const FormattedStringBuilder &other) {

    *this = other;

}

FormattedStringBuilder &FormattedStringBuilder::operator=(const FormattedStringBuilder &other) {

    // Check for self-assignment

    if (this == &other) {

        return *this;

    }

    // Continue with deallocation and copying

    if (fUsingHeap) {

        uprv_free(fChars.heap.ptr);

        uprv_free(fFields.heap.ptr);

        fUsingHeap = false;

    }

    int32_t capacity = other.getCapacity();

    if (capacity > DEFAULT_CAPACITY) {

        // FIXME: uprv_malloc

        // C++ note: malloc appears in two places: here and in prepareForInsertHelper.

        auto newChars = static_cast<char16_t *> (uprv_malloc(sizeof(char16_t) * capacity));

        auto newFields = static_cast<Field *>(uprv_malloc(sizeof(Field) * capacity));

        if (newChars == nullptr || newFields == nullptr) {

            // UErrorCode is not available; fail silently.

            uprv_free(newChars);

            uprv_free(newFields);

            *this = FormattedStringBuilder();  // can't fail

            return *this;

        }

        fUsingHeap = true;

        fChars.heap.capacity = capacity;

        fChars.heap.ptr = newChars;

        fFields.heap.capacity = capacity;

        fFields.heap.ptr = newFields;

    }

    uprv_memcpy2(getCharPtr(), other.getCharPtr(), sizeof(char16_t) * capacity);

    uprv_memcpy2(getFieldPtr(), other.getFieldPtr(), sizeof(Field) * capacity);

    fZero = other.fZero;

    fLength = other.fLength;

    return *this;

}

int32_t FormattedStringBuilder::length() const {

    return fLength;

}

int32_t FormattedStringBuilder::codePointCount() const {

    return u_countChar32(getCharPtr() + fZero, fLength);

}

UChar32 FormattedStringBuilder::getFirstCodePoint() const {

    if (fLength == 0) {

        return -1;

    }

    UChar32 cp;

    U16_GET(getCharPtr() + fZero, 0, 0, fLength, cp);

    return cp;

}

UChar32 FormattedStringBuilder::getLastCodePoint() const {

    if (fLength == 0) {

        return -1;

    }

    int32_t offset = fLength;

    U16_BACK_1(getCharPtr() + fZero, 0, offset);

    UChar32 cp;

    U16_GET(getCharPtr() + fZero, 0, offset, fLength, cp);

    return cp;

}

UChar32 FormattedStringBuilder::codePointAt(int32_t index) const {

    UChar32 cp;

    U16_GET(getCharPtr() + fZero, 0, index, fLength, cp);

    return cp;

}

UChar32 FormattedStringBuilder::codePointBefore(int32_t index) const {

    int32_t offset = index;

    U16_BACK_1(getCharPtr() + fZero, 0, offset);

    UChar32 cp;

    U16_GET(getCharPtr() + fZero, 0, offset, fLength, cp);

    return cp;

}

FormattedStringBuilder &FormattedStringBuilder::clear() {

    // TODO: Reset the heap here?

    fZero = getCapacity() / 2;

    fLength = 0;

    return *this;

}

int32_t

FormattedStringBuilder::insertCodePoint(int32_t index, UChar32 codePoint, Field field, UErrorCode &status) {

    int32_t count = U16_LENGTH(codePoint);

    int32_t position = prepareForInsert(index, count, status);

    if (U_FAILURE(status)) {

        return count;

    }

    if (count == 1) {

        getCharPtr()[position] = (char16_t) codePoint;

        getFieldPtr()[position] = field;

    } else {

        getCharPtr()[position] = U16_LEAD(codePoint);

        getCharPtr()[position + 1] = U16_TRAIL(codePoint);

        getFieldPtr()[position] = getFieldPtr()[position + 1] = field;

    }

    return count;

}

int32_t FormattedStringBuilder::insert(int32_t index, const UnicodeString &unistr, Field field,

                                    UErrorCode &status) {

    if (unistr.length() == 0) {

        // Nothing to insert.

        return 0;

    } else if (unistr.length() == 1) {

        // Fast path: insert using insertCodePoint.

        return insertCodePoint(index, unistr.charAt(0), field, status);

    } else {

        return insert(index, unistr, 0, unistr.length(), field, status);

    }

}

int32_t

FormattedStringBuilder::insert(int32_t index, const UnicodeString &unistr, int32_t start, int32_t end,

                            Field field, UErrorCode &status) {

    int32_t count = end - start;

    int32_t position = prepareForInsert(index, count, status);

    if (U_FAILURE(status)) {

        return count;

    }

    for (int32_t i = 0; i < count; i++) {

        getCharPtr()[position + i] = unistr.charAt(start + i);

        getFieldPtr()[position + i] = field;

    }

    return count;

}

int32_t

FormattedStringBuilder::splice(int32_t startThis, int32_t endThis,  const UnicodeString &unistr,

                            int32_t startOther, int32_t endOther, Field field, UErrorCode& status) {

    int32_t thisLength = endThis - startThis;

    int32_t otherLength = endOther - startOther;

    int32_t count = otherLength - thisLength;

    int32_t position;

    if (count > 0) {

        // Overall, chars need to be added.

        position = prepareForInsert(startThis, count, status);

    } else {

        // Overall, chars need to be removed or kept the same.

        position = remove(startThis, -count);

    }

    if (U_FAILURE(status)) {

        return count;

    }

    for (int32_t i = 0; i < otherLength; i++) {

        getCharPtr()[position + i] = unistr.charAt(startOther + i);

        getFieldPtr()[position + i] = field;

    }

    return count;

}

int32_t FormattedStringBuilder::append(const FormattedStringBuilder &other, UErrorCode &status) {

    return insert(fLength, other, status);

}

int32_t

FormattedStringBuilder::insert(int32_t index, const FormattedStringBuilder &other, UErrorCode &status) {

    if (this == &other) {

        status = U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    int32_t count = other.fLength;

    if (count == 0) {

        // Nothing to insert.

        return 0;

    }

    int32_t position = prepareForInsert(index, count, status);

    if (U_FAILURE(status)) {

        return count;

    }

    for (int32_t i = 0; i < count; i++) {

        getCharPtr()[position + i] = other.charAt(i);

        getFieldPtr()[position + i] = other.fieldAt(i);

    }

    return count;

}

void FormattedStringBuilder::writeTerminator(UErrorCode& status) {

    int32_t position = prepareForInsert(fLength, 1, status);

    if (U_FAILURE(status)) {

        return;

    }

    getCharPtr()[position] = 0;

    getFieldPtr()[position] = kUndefinedField;

    fLength--;

}

int32_t FormattedStringBuilder::prepareForInsert(int32_t index, int32_t count, UErrorCode &status) {

    U_ASSERT(index >= 0);

    U_ASSERT(index <= fLength);

    U_ASSERT(count >= 0);

    if (index == 0 && fZero - count >= 0) {

        // Append to start

        fZero -= count;

        fLength += count;

        return fZero;

    } else if (index == fLength && fZero + fLength + count < getCapacity()) {

        // Append to end

        fLength += count;

        return fZero + fLength - count;

    } else {

        // Move chars around and/or allocate more space

        return prepareForInsertHelper(index, count, status);

    }

}

int32_t FormattedStringBuilder::prepareForInsertHelper(int32_t index, int32_t count, UErrorCode &status) {

    int32_t oldCapacity = getCapacity();

    int32_t oldZero = fZero;

    char16_t *oldChars = getCharPtr();

    Field *oldFields = getFieldPtr();

    if (fLength + count > oldCapacity) {

        if ((fLength + count) > INT32_MAX / 2) {

            // If we continue, then newCapacity will overflow int32_t in the next line.

            status = U_INPUT_TOO_LONG_ERROR;

            return -1;

        }

        int32_t newCapacity = (fLength + count) * 2;

        int32_t newZero = newCapacity / 2 - (fLength + count) / 2;

        // C++ note: malloc appears in two places: here and in the assignment operator.

        auto newChars = static_cast<char16_t *> (uprv_malloc(sizeof(char16_t) * newCapacity));

        auto newFields = static_cast<Field *>(uprv_malloc(sizeof(Field) * newCapacity));

        if (newChars == nullptr || newFields == nullptr) {

            uprv_free(newChars);

            uprv_free(newFields);

            status = U_MEMORY_ALLOCATION_ERROR;

            return -1;

        }

        // First copy the prefix and then the suffix, leaving room for the new chars that the

        // caller wants to insert.

        // C++ note: memcpy is OK because the src and dest do not overlap.

        uprv_memcpy2(newChars + newZero, oldChars + oldZero, sizeof(char16_t) * index);

        uprv_memcpy2(newChars + newZero + index + count,

                oldChars + oldZero + index,

                sizeof(char16_t) * (fLength - index));

        uprv_memcpy2(newFields + newZero, oldFields + oldZero, sizeof(Field) * index);

        uprv_memcpy2(newFields + newZero + index + count,

                oldFields + oldZero + index,

                sizeof(Field) * (fLength - index));

        if (fUsingHeap) {

            uprv_free(oldChars);

            uprv_free(oldFields);

        }

        fUsingHeap = true;

        fChars.heap.ptr = newChars;

        fChars.heap.capacity = newCapacity;

        fFields.heap.ptr = newFields;

        fFields.heap.capacity = newCapacity;

        fZero = newZero;

        fLength += count;

    } else {

        int32_t newZero = oldCapacity / 2 - (fLength + count) / 2;

        // C++ note: memmove is required because src and dest may overlap.

        // First copy the entire string to the location of the prefix, and then move the suffix

        // to make room for the new chars that the caller wants to insert.

        uprv_memmove2(oldChars + newZero, oldChars + oldZero, sizeof(char16_t) * fLength);

        uprv_memmove2(oldChars + newZero + index + count,

                oldChars + newZero + index,

                sizeof(char16_t) * (fLength - index));

        uprv_memmove2(oldFields + newZero, oldFields + oldZero, sizeof(Field) * fLength);

        uprv_memmove2(oldFields + newZero + index + count,

                oldFields + newZero + index,

                sizeof(Field) * (fLength - index));

        fZero = newZero;

        fLength += count;

    }

    U_ASSERT((fZero + index) >= 0);

    return fZero + index;

}

int32_t FormattedStringBuilder::remove(int32_t index, int32_t count) {

    // TODO: Reset the heap here?  (If the string after removal can fit on stack?)

    int32_t position = index + fZero;

    U_ASSERT(position >= 0);

    uprv_memmove2(getCharPtr() + position,

            getCharPtr() + position + count,

            sizeof(char16_t) * (fLength - index - count));

    uprv_memmove2(getFieldPtr() + position,

            getFieldPtr() + position + count,

            sizeof(Field) * (fLength - index - count));

    fLength -= count;

    return position;

}

UnicodeString FormattedStringBuilder::toUnicodeString() const {

    return UnicodeString(getCharPtr() + fZero, fLength);

}

const UnicodeString FormattedStringBuilder::toTempUnicodeString() const {

    // Readonly-alias constructor:

    return UnicodeString(FALSE, getCharPtr() + fZero, fLength);

}

UnicodeString FormattedStringBuilder::toDebugString() const {

    UnicodeString sb;

    sb.append(u"<FormattedStringBuilder [", -1);

    sb.append(toUnicodeString());

    sb.append(u"] [", -1);

    for (int i = 0; i < fLength; i++) {

        if (fieldAt(i) == kUndefinedField) {

            sb.append(u'n');

        } else if (fieldAt(i).getCategory() == UFIELD_CATEGORY_NUMBER) {

            char16_t c;

            switch (fieldAt(i).getField()) {

                case UNUM_SIGN_FIELD:

                    c = u'-';

                    break;

                case UNUM_INTEGER_FIELD:

                    c = u'i';

                    break;

                case UNUM_FRACTION_FIELD:

                    c = u'f';

                    break;

                case UNUM_EXPONENT_FIELD:

                    c = u'e';

                    break;

                case UNUM_EXPONENT_SIGN_FIELD:

                    c = u'+';

                    break;

                case UNUM_EXPONENT_SYMBOL_FIELD:

                    c = u'E';

                    break;

                case UNUM_DECIMAL_SEPARATOR_FIELD:

                    c = u'.';

                    break;

                case UNUM_GROUPING_SEPARATOR_FIELD:

                    c = u',';

                    break;

                case UNUM_PERCENT_FIELD:

                    c = u'%';

                    break;

                case UNUM_PERMILL_FIELD:

                    c = u'‰';

                    break;

                case UNUM_CURRENCY_FIELD:

                    c = u'$';

                    break;

                default:

                    c = u'0' + fieldAt(i).getField();

                    break;

            }

            sb.append(c);

        } else {

            sb.append(u'0' + fieldAt(i).getCategory());

        }

    }

    sb.append(u"]>", -1);

    return sb;

}

const char16_t *FormattedStringBuilder::chars() const {

    return getCharPtr() + fZero;

}

bool FormattedStringBuilder::contentEquals(const FormattedStringBuilder &other) const {

    if (fLength != other.fLength) {

        return false;

    }

    for (int32_t i = 0; i < fLength; i++) {

        if (charAt(i) != other.charAt(i) || fieldAt(i) != other.fieldAt(i)) {

            return false;

        }

    }

    return true;

}

bool FormattedStringBuilder::containsField(Field field) const {

    for (int32_t i = 0; i < fLength; i++) {

        if (field == fieldAt(i)) {

            return true;

        }

    }

    return false;

}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_FORMATTING */