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

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

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

// This file contains one implementation of FormattedValue.

// Other independent implementations should go into their own cpp file for

// better dependency modularization.

#include "unicode/ustring.h"

#include "formattedval_impl.h"

#include "number_types.h"

#include "formatted_string_builder.h"

#include "number_utils.h"

#include "static_unicode_sets.h"

#include "unicode/listformatter.h"

U_NAMESPACE_BEGIN

typedef FormattedStringBuilder::Field Field;

FormattedValueStringBuilderImpl::FormattedValueStringBuilderImpl(Field numericField)

        : fNumericField(numericField) {

}

FormattedValueStringBuilderImpl::~FormattedValueStringBuilderImpl() {

}

UnicodeString FormattedValueStringBuilderImpl::toString(UErrorCode&) const {

    return fString.toUnicodeString();

}

UnicodeString FormattedValueStringBuilderImpl::toTempString(UErrorCode&) const {

    return fString.toTempUnicodeString();

}

Appendable& FormattedValueStringBuilderImpl::appendTo(Appendable& appendable, UErrorCode&) const {

    appendable.appendString(fString.chars(), fString.length());

    return appendable;

}

UBool FormattedValueStringBuilderImpl::nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const {

    // NOTE: MSVC sometimes complains when implicitly converting between bool and UBool

    return nextPositionImpl(cfpos, fNumericField, status) ? true : false;

}

UBool FormattedValueStringBuilderImpl::nextFieldPosition(FieldPosition& fp, UErrorCode& status) const {

    int32_t rawField = fp.getField();

    if (rawField == FieldPosition::DONT_CARE) {

        return false;

    }

    if (rawField < 0 || rawField >= UNUM_FIELD_COUNT) {

        status = U_ILLEGAL_ARGUMENT_ERROR;

        return false;

    }

    ConstrainedFieldPosition cfpos;

    cfpos.constrainField(UFIELD_CATEGORY_NUMBER, rawField);

    cfpos.setState(UFIELD_CATEGORY_NUMBER, rawField, fp.getBeginIndex(), fp.getEndIndex());

    if (nextPositionImpl(cfpos, kUndefinedField, status)) {

        fp.setBeginIndex(cfpos.getStart());

        fp.setEndIndex(cfpos.getLimit());

        return true;

    }

    // Special case: fraction should start after integer if fraction is not present

    if (rawField == UNUM_FRACTION_FIELD && fp.getEndIndex() == 0) {

        bool inside = false;

        int32_t i = fString.fZero;

        for (; i < fString.fZero + fString.fLength; i++) {

            if (isIntOrGroup(fString.getFieldPtr()[i]) || fString.getFieldPtr()[i] == Field(UFIELD_CATEGORY_NUMBER, UNUM_DECIMAL_SEPARATOR_FIELD)) {

                inside = true;

            } else if (inside) {

                break;

            }

        }

        fp.setBeginIndex(i - fString.fZero);

        fp.setEndIndex(i - fString.fZero);

    }

    return false;

}

void FormattedValueStringBuilderImpl::getAllFieldPositions(FieldPositionIteratorHandler& fpih,

                                               UErrorCode& status) const {

    ConstrainedFieldPosition cfpos;

    while (nextPositionImpl(cfpos, kUndefinedField, status)) {

        fpih.addAttribute(cfpos.getField(), cfpos.getStart(), cfpos.getLimit());

    }

}

void FormattedValueStringBuilderImpl::resetString() {

    fString.clear();

    spanIndicesCount = 0;

}

// Signal the end of the string using a field that doesn't exist and that is

// different from kUndefinedField, which is used for "null field".

static constexpr Field kEndField = Field(0xf, 0xf);

bool FormattedValueStringBuilderImpl::nextPositionImpl(ConstrainedFieldPosition& cfpos, Field numericField, UErrorCode& /*status*/) const {

    int32_t fieldStart = -1;

    Field currField = kUndefinedField;

    bool prevIsSpan = false;

    int32_t nextSpanStart = -1;

    if (spanIndicesCount > 0) {

        int64_t si = cfpos.getInt64IterationContext();

        U_ASSERT(si <= spanIndicesCount);

        if (si < spanIndicesCount) {

            nextSpanStart = spanIndices[si].start;

        }

        if (si > 0) {

            prevIsSpan = cfpos.getCategory() == spanIndices[si-1].category

                && cfpos.getField() == spanIndices[si-1].spanValue;

        }

    }

    bool prevIsNumeric = false;

    if (numericField != kUndefinedField) {

        prevIsNumeric = cfpos.getCategory() == numericField.getCategory()

            && cfpos.getField() == numericField.getField();

    }

    bool prevIsInteger = cfpos.getCategory() == UFIELD_CATEGORY_NUMBER

        && cfpos.getField() == UNUM_INTEGER_FIELD;

    for (int32_t i = fString.fZero + cfpos.getLimit(); i <= fString.fZero + fString.fLength; i++) {

        Field _field = (i < fString.fZero + fString.fLength) ? fString.getFieldPtr()[i] : kEndField;

        // Case 1: currently scanning a field.

        if (currField != kUndefinedField) {

            if (currField != _field) {

                int32_t end = i - fString.fZero;

                // Grouping separators can be whitespace; don't throw them out!

                if (isTrimmable(currField)) {

                    end = trimBack(i - fString.fZero);

                }

                if (end <= fieldStart) {

                    // Entire field position is ignorable; skip.

                    fieldStart = -1;

                    currField = kUndefinedField;

                    i--;  // look at this index again

                    continue;

                }

                int32_t start = fieldStart;

                if (isTrimmable(currField)) {

                    start = trimFront(start);

                }

                cfpos.setState(currField.getCategory(), currField.getField(), start, end);

                return true;

            }

            continue;

        }

        // Special case: emit normalField if we are pointing at the end of spanField.

        if (i > fString.fZero && prevIsSpan) {

            int64_t si = cfpos.getInt64IterationContext() - 1;

            U_ASSERT(si >= 0);

            int32_t previ = i - spanIndices[si].length;

            U_ASSERT(previ >= fString.fZero);

            Field prevField = fString.getFieldPtr()[previ];

            if (prevField == Field(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD)) {

                // Special handling for ULISTFMT_ELEMENT_FIELD

                if (cfpos.matchesField(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD)) {

                    fieldStart = i - fString.fZero - spanIndices[si].length;

                    int32_t end = fieldStart + spanIndices[si].length;

                    cfpos.setState(

                        UFIELD_CATEGORY_LIST,

                        ULISTFMT_ELEMENT_FIELD,

                        fieldStart,

                        end);

                    return true;

                } else {

                    prevIsSpan = false;

                }

            } else {

                // Re-wind, since there may be multiple fields in the span.

                i = previ;

                _field = prevField;

            }

        }

        // Special case: coalesce the INTEGER if we are pointing at the end of the INTEGER.

        if (cfpos.matchesField(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD)

                && i > fString.fZero

                && !prevIsInteger

                && !prevIsNumeric

                && isIntOrGroup(fString.getFieldPtr()[i - 1])

                && !isIntOrGroup(_field)) {

            int j = i - 1;

            for (; j >= fString.fZero && isIntOrGroup(fString.getFieldPtr()[j]); j--) {}

            cfpos.setState(

                UFIELD_CATEGORY_NUMBER,

                UNUM_INTEGER_FIELD,

                j - fString.fZero + 1,

                i - fString.fZero);

            return true;

        }

        // Special case: coalesce NUMERIC if we are pointing at the end of the NUMERIC.

        if (numericField != kUndefinedField

                && cfpos.matchesField(numericField.getCategory(), numericField.getField())

                && i > fString.fZero

                && !prevIsNumeric

                && fString.getFieldPtr()[i - 1].isNumeric()

                && !_field.isNumeric()) {

            // Re-wind to the beginning of the field and then emit it

            int32_t j = i - 1;

            for (; j >= fString.fZero && fString.getFieldPtr()[j].isNumeric(); j--) {}

            cfpos.setState(

                numericField.getCategory(),

                numericField.getField(),

                j - fString.fZero + 1,

                i - fString.fZero);

            return true;

        }

        // Check for span field

        if (!prevIsSpan && (

                _field == Field(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD) ||

                i - fString.fZero == nextSpanStart)) {

            int64_t si = cfpos.getInt64IterationContext();

            if (si >= spanIndicesCount) {

                break;

            }

            UFieldCategory spanCategory = spanIndices[si].category;

            int32_t spanValue = spanIndices[si].spanValue;

            int32_t length = spanIndices[si].length;

            cfpos.setInt64IterationContext(si + 1);

            if (si + 1 < spanIndicesCount) {

                nextSpanStart = spanIndices[si + 1].start;

            }

            if (length == 0) {

                // ICU-21871: Don't return fields on empty spans

                i--;

                continue;

            }

            if (cfpos.matchesField(spanCategory, spanValue)) {

                fieldStart = i - fString.fZero;

                int32_t end = fieldStart + length;

                cfpos.setState(

                    spanCategory,

                    spanValue,

                    fieldStart,

                    end);

                return true;

            } else if (_field == Field(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD)) {

                // Special handling for ULISTFMT_ELEMENT_FIELD

                if (cfpos.matchesField(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD)) {

                    fieldStart = i - fString.fZero;

                    int32_t end = fieldStart + length;

                    cfpos.setState(

                        UFIELD_CATEGORY_LIST,

                        ULISTFMT_ELEMENT_FIELD,

                        fieldStart,

                        end);

                    return true;

                } else {

                    // Failed to match; jump ahead

                    i += length - 1;

                    // goto loopend

                }

            }

        }

        // Special case: skip over INTEGER; will be coalesced later.

        else if (_field == Field(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD)) {

            _field = kUndefinedField;

        }

        // No field starting at this position.

        else if (_field.isUndefined() || _field == kEndField) {

            // goto loopend

        }

        // No SpanField

        else if (cfpos.matchesField(_field.getCategory(), _field.getField())) {

            fieldStart = i - fString.fZero;

            currField = _field;

        }

        // loopend:

        prevIsSpan = false;

        prevIsNumeric = false;

        prevIsInteger = false;

    }

    U_ASSERT(currField == kUndefinedField);

    // Always set the position to the end so that we don't revisit previous sections

    cfpos.setState(

        cfpos.getCategory(),

        cfpos.getField(),

        fString.fLength,

        fString.fLength);

    return false;

}

void FormattedValueStringBuilderImpl::appendSpanInfo(UFieldCategory category, int32_t spanValue, int32_t start, int32_t length, UErrorCode& status) {

    if (U_FAILURE(status)) { return; }

    U_ASSERT(spanIndices.getCapacity() >= spanIndicesCount);

    if (spanIndices.getCapacity() == spanIndicesCount) {

        if (!spanIndices.resize(spanIndicesCount * 2, spanIndicesCount)) {

            status = U_MEMORY_ALLOCATION_ERROR;

            return;

        }

    }

    spanIndices[spanIndicesCount] = {category, spanValue, start, length};

    spanIndicesCount++;

}

void FormattedValueStringBuilderImpl::prependSpanInfo(UFieldCategory category, int32_t spanValue, int32_t start, int32_t length, UErrorCode& status) {

    if (U_FAILURE(status)) { return; }

    U_ASSERT(spanIndices.getCapacity() >= spanIndicesCount);

    if (spanIndices.getCapacity() == spanIndicesCount) {

        if (!spanIndices.resize(spanIndicesCount * 2, spanIndicesCount)) {

            status = U_MEMORY_ALLOCATION_ERROR;

            return;

        }

    }

    for (int32_t i = spanIndicesCount - 1; i >= 0; i--) {

        spanIndices[i+1] = spanIndices[i];

    }

    spanIndices[0] = {category, spanValue, start, length};

    spanIndicesCount++;

}

bool FormattedValueStringBuilderImpl::isIntOrGroup(Field field) {

    return field == Field(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD)

        || field == Field(UFIELD_CATEGORY_NUMBER, UNUM_GROUPING_SEPARATOR_FIELD);

}

bool FormattedValueStringBuilderImpl::isTrimmable(Field field) {

    return field != Field(UFIELD_CATEGORY_NUMBER, UNUM_GROUPING_SEPARATOR_FIELD)

        && field.getCategory() != UFIELD_CATEGORY_LIST;

}

int32_t FormattedValueStringBuilderImpl::trimBack(int32_t limit) const {

    return unisets::get(unisets::DEFAULT_IGNORABLES)->spanBack(

        fString.getCharPtr() + fString.fZero,

        limit,

        USET_SPAN_CONTAINED);

}

int32_t FormattedValueStringBuilderImpl::trimFront(int32_t start) const {

    return start + unisets::get(unisets::DEFAULT_IGNORABLES)->span(

        fString.getCharPtr() + fString.fZero + start,

        fString.fLength - start,

        USET_SPAN_CONTAINED);

}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_FORMATTING */