// © 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

// Allow implicit conversion from char16_t* to UnicodeString for this file:

// Helpful in toString methods and elsewhere.

#define UNISTR_FROM_STRING_EXPLICIT

#include "number_mapper.h"

#include "number_patternstring.h"

#include "unicode/errorcode.h"

#include "number_utils.h"

using namespace icu;

using namespace icu::number;

using namespace icu::number::impl;

UnlocalizedNumberFormatter NumberPropertyMapper::create(const DecimalFormatProperties& properties,

                                                        const DecimalFormatSymbols& symbols,

                                                        DecimalFormatWarehouse& warehouse,

                                                        UErrorCode& status) {

    return NumberFormatter::with().macros(oldToNew(properties, symbols, warehouse, nullptr, status));

}

UnlocalizedNumberFormatter NumberPropertyMapper::create(const DecimalFormatProperties& properties,

                                                        const DecimalFormatSymbols& symbols,

                                                        DecimalFormatWarehouse& warehouse,

                                                        DecimalFormatProperties& exportedProperties,

                                                        UErrorCode& status) {

    return NumberFormatter::with().macros(

            oldToNew(

                    properties, symbols, warehouse, &exportedProperties, status));

}

MacroProps NumberPropertyMapper::oldToNew(const DecimalFormatProperties& properties,

                                          const DecimalFormatSymbols& symbols,

                                          DecimalFormatWarehouse& warehouse,

                                          DecimalFormatProperties* exportedProperties,

                                          UErrorCode& status) {

    MacroProps macros;

    Locale locale = symbols.getLocale();

    /////////////

    // SYMBOLS //

    /////////////

    macros.symbols.setTo(symbols);

    //////////////////

    // PLURAL RULES //

    //////////////////

    if (!properties.currencyPluralInfo.fPtr.isNull()) {

        macros.rules = properties.currencyPluralInfo.fPtr->getPluralRules();

    }

    /////////////

    // AFFIXES //

    /////////////

    warehouse.affixProvider.setTo(properties, status);

    macros.affixProvider = &warehouse.affixProvider.get();

    ///////////

    // UNITS //

    ///////////

    bool useCurrency = (

            !properties.currency.isNull() ||

            !properties.currencyPluralInfo.fPtr.isNull() ||

            !properties.currencyUsage.isNull() ||

            warehouse.affixProvider.get().hasCurrencySign());

    CurrencyUnit currency;

    UCurrencyUsage currencyUsage;

    if (useCurrency) {

        currency = resolveCurrency(properties, locale, status);

        currencyUsage = properties.currencyUsage.getOrDefault(UCURR_USAGE_STANDARD);

        // NOTE: Slicing is OK.

        macros.unit = currency; // NOLINT

    }

    ///////////////////////

    // ROUNDING STRATEGY //

    ///////////////////////

    int32_t maxInt = properties.maximumIntegerDigits;

    int32_t minInt = properties.minimumIntegerDigits;

    int32_t maxFrac = properties.maximumFractionDigits;

    int32_t minFrac = properties.minimumFractionDigits;

    int32_t minSig = properties.minimumSignificantDigits;

    int32_t maxSig = properties.maximumSignificantDigits;

    double roundingIncrement = properties.roundingIncrement;

    // Not assigning directly to macros.roundingMode here: we change

    // roundingMode if and when we also change macros.precision.

    RoundingMode roundingMode = properties.roundingMode.getOrDefault(UNUM_ROUND_HALFEVEN);

    bool explicitMinMaxFrac = minFrac != -1 || maxFrac != -1;

    bool explicitMinMaxSig = minSig != -1 || maxSig != -1;

    // Resolve min/max frac for currencies, required for the validation logic and for when minFrac or

    // maxFrac was

    // set (but not both) on a currency instance.

    // NOTE: Increments are handled in "Precision.constructCurrency()".

    if (useCurrency && (minFrac == -1 || maxFrac == -1)) {

        int32_t digits = ucurr_getDefaultFractionDigitsForUsage(

                currency.getISOCurrency(), currencyUsage, &status);

        if (minFrac == -1 && maxFrac == -1) {

            minFrac = digits;

            maxFrac = digits;

        } else if (minFrac == -1) {

            minFrac = std::min(maxFrac, digits);

        } else /* if (maxFrac == -1) */ {

            maxFrac = std::max(minFrac, digits);

        }

    }

    // Validate min/max int/frac.

    // For backwards compatibility, minimum overrides maximum if the two conflict.

    if (minInt == 0 && maxFrac != 0) {

        minFrac = (minFrac < 0 || (minFrac == 0 && maxInt == 0)) ? 1 : minFrac;

        maxFrac = maxFrac < 0 ? -1 : maxFrac < minFrac ? minFrac : maxFrac;

        minInt = 0;

        maxInt = maxInt < 0 ? -1 : maxInt > kMaxIntFracSig ? -1 : maxInt;

    } else {

        // Force a digit before the decimal point.

        minFrac = minFrac < 0 ? 0 : minFrac;

        maxFrac = maxFrac < 0 ? -1 : maxFrac < minFrac ? minFrac : maxFrac;

        minInt = minInt <= 0 ? 1 : minInt > kMaxIntFracSig ? 1 : minInt;

        maxInt = maxInt < 0 ? -1 : maxInt < minInt ? minInt : maxInt > kMaxIntFracSig ? -1 : maxInt;

    }

    Precision precision;

    if (!properties.currencyUsage.isNull()) {

        U_ASSERT(useCurrency);

        precision = Precision::constructCurrency(currencyUsage).withCurrency(currency);

    } else if (roundingIncrement != 0.0) {

        if (PatternStringUtils::ignoreRoundingIncrement(roundingIncrement, maxFrac)) {

            precision = Precision::constructFraction(minFrac, maxFrac);

        } else {

            // Convert the double increment to an integer increment

            precision = Precision::increment(roundingIncrement).withMinFraction(minFrac);

        }

    } else if (explicitMinMaxSig) {

        minSig = minSig < 1 ? 1 : minSig > kMaxIntFracSig ? kMaxIntFracSig : minSig;

        maxSig = maxSig < 0 ? kMaxIntFracSig : maxSig < minSig ? minSig : maxSig > kMaxIntFracSig

                                                                          ? kMaxIntFracSig : maxSig;

        precision = Precision::constructSignificant(minSig, maxSig);

    } else if (explicitMinMaxFrac) {

        precision = Precision::constructFraction(minFrac, maxFrac);

    } else if (useCurrency) {

        precision = Precision::constructCurrency(currencyUsage);

    }

    if (!precision.isBogus()) {

        macros.roundingMode = roundingMode;

        macros.precision = precision;

    }

    ///////////////////

    // INTEGER WIDTH //

    ///////////////////

    macros.integerWidth = IntegerWidth(

            static_cast<digits_t>(minInt),

            static_cast<digits_t>(maxInt),

            properties.formatFailIfMoreThanMaxDigits);

    ///////////////////////

    // GROUPING STRATEGY //

    ///////////////////////

    macros.grouper = Grouper::forProperties(properties);

    /////////////

    // PADDING //

    /////////////

    if (properties.formatWidth > 0) {

        macros.padder = Padder::forProperties(properties);

    }

    ///////////////////////////////

    // DECIMAL MARK ALWAYS SHOWN //

    ///////////////////////////////

    macros.decimal = properties.decimalSeparatorAlwaysShown ? UNUM_DECIMAL_SEPARATOR_ALWAYS

                                                            : UNUM_DECIMAL_SEPARATOR_AUTO;

    ///////////////////////

    // SIGN ALWAYS SHOWN //

    ///////////////////////

    macros.sign = properties.signAlwaysShown ? UNUM_SIGN_ALWAYS : UNUM_SIGN_AUTO;

    /////////////////////////

    // SCIENTIFIC NOTATION //

    /////////////////////////

    if (properties.minimumExponentDigits != -1) {

        // Scientific notation is required.

        // This whole section feels like a hack, but it is needed for regression tests.

        // The mapping from property bag to scientific notation is nontrivial due to LDML rules.

        if (maxInt > 8) {

            // But #13110: The maximum of 8 digits has unknown origins and is not in the spec.

            // If maxInt is greater than 8, it is set to minInt, even if minInt is greater than 8.

            maxInt = minInt;

            macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);

        } else if (maxInt > minInt && minInt > 1) {

            // Bug #13289: if maxInt > minInt > 1, then minInt should be 1.

            minInt = 1;

            macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);

        }

        int engineering = maxInt < 0 ? -1 : maxInt;

        macros.notation = ScientificNotation(

                // Engineering interval:

                static_cast<int8_t>(engineering),

                // Enforce minimum integer digits (for patterns like "000.00E0"):

                (engineering == minInt),

                // Minimum exponent digits:

                static_cast<digits_t>(properties.minimumExponentDigits),

                // Exponent sign always shown:

                properties.exponentSignAlwaysShown ? UNUM_SIGN_ALWAYS : UNUM_SIGN_AUTO);

        // Scientific notation also involves overriding the rounding mode.

        // TODO: Overriding here is a bit of a hack. Should this logic go earlier?

        if (macros.precision.fType == Precision::PrecisionType::RND_FRACTION) {

            // For the purposes of rounding, get the original min/max int/frac, since the local

            // variables have been manipulated for display purposes.

            int maxInt_ = properties.maximumIntegerDigits;

            int minInt_ = properties.minimumIntegerDigits;

            int minFrac_ = properties.minimumFractionDigits;

            int maxFrac_ = properties.maximumFractionDigits;

            if (minInt_ == 0 && maxFrac_ == 0) {

                // Patterns like "#E0" and "##E0", which mean no rounding!

                macros.precision = Precision::unlimited();

            } else if (minInt_ == 0 && minFrac_ == 0) {

                // Patterns like "#.##E0" (no zeros in the mantissa), which mean round to maxFrac+1

                macros.precision = Precision::constructSignificant(1, maxFrac_ + 1);

            } else {

                int maxSig_ = minInt_ + maxFrac_;

                // Bug #20058: if maxInt_ > minInt_ > 1, then minInt_ should be 1.

                if (maxInt_ > minInt_ && minInt_ > 1) {

                    minInt_ = 1;

                }

                int minSig_ = minInt_ + minFrac_;

                // To avoid regression, maxSig is not reset when minInt_ set to 1.

                // TODO: Reset maxSig_ = 1 + minFrac_ to follow the spec.

                macros.precision = Precision::constructSignificant(minSig_, maxSig_);

            }

            macros.roundingMode = roundingMode;

        }

    }

    //////////////////////

    // COMPACT NOTATION //

    //////////////////////

    if (!properties.compactStyle.isNull()) {

        if (properties.compactStyle.getNoError() == UNumberCompactStyle::UNUM_LONG) {

            macros.notation = Notation::compactLong();

        } else {

            macros.notation = Notation::compactShort();

        }

    }

    /////////////////

    // MULTIPLIERS //

    /////////////////

    macros.scale = scaleFromProperties(properties);

    //////////////////////

    // PROPERTY EXPORTS //

    //////////////////////

    if (exportedProperties != nullptr) {

        exportedProperties->currency = currency;

        exportedProperties->roundingMode = roundingMode;

        exportedProperties->minimumIntegerDigits = minInt;

        exportedProperties->maximumIntegerDigits = maxInt == -1 ? INT32_MAX : maxInt;

        Precision rounding_;

        if (useCurrency && precision.fType == Precision::PrecisionType::RND_CURRENCY) {

            rounding_ = precision.withCurrency(currency, status);

        } else {

            rounding_ = precision;

        }

        int minFrac_ = minFrac;

        int maxFrac_ = maxFrac;

        int minSig_ = minSig;

        int maxSig_ = maxSig;

        double increment_ = 0.0;

        if (rounding_.fType == Precision::PrecisionType::RND_FRACTION) {

            minFrac_ = rounding_.fUnion.fracSig.fMinFrac;

            maxFrac_ = rounding_.fUnion.fracSig.fMaxFrac;

        } else if (rounding_.fType == Precision::PrecisionType::RND_INCREMENT

                || rounding_.fType == Precision::PrecisionType::RND_INCREMENT_ONE

                || rounding_.fType == Precision::PrecisionType::RND_INCREMENT_FIVE) {

            minFrac_ = rounding_.fUnion.increment.fMinFrac;

            // If incrementRounding is used, maxFrac is set equal to minFrac

            maxFrac_ = rounding_.fUnion.increment.fMinFrac;

            // Convert the integer increment to a double

            DecimalQuantity dq;

            dq.setToLong(rounding_.fUnion.increment.fIncrement);

            dq.adjustMagnitude(rounding_.fUnion.increment.fIncrementMagnitude);

            increment_ = dq.toDouble();

        } else if (rounding_.fType == Precision::PrecisionType::RND_SIGNIFICANT) {

            minSig_ = rounding_.fUnion.fracSig.fMinSig;

            maxSig_ = rounding_.fUnion.fracSig.fMaxSig;

        }

        exportedProperties->minimumFractionDigits = minFrac_;

        exportedProperties->maximumFractionDigits = maxFrac_;

        exportedProperties->minimumSignificantDigits = minSig_;

        exportedProperties->maximumSignificantDigits = maxSig_;

        exportedProperties->roundingIncrement = increment_;

    }

    return macros;

}

void PropertiesAffixPatternProvider::setTo(const DecimalFormatProperties& properties, UErrorCode& status) {

    fBogus = false;

    // There are two ways to set affixes in DecimalFormat: via the pattern string (applyPattern), and via the

    // explicit setters (setPositivePrefix and friends).  The way to resolve the settings is as follows:

    //

    // 1) If the explicit setting is present for the field, use it.

    // 2) Otherwise, follows UTS 35 rules based on the pattern string.

    //

    // Importantly, the explicit setters affect only the one field they override.  If you set the positive

    // prefix, that should not affect the negative prefix.

    // Convenience: Extract the properties into local variables.

    // Variables are named with three chars: [p/n][p/s][o/p]

    // [p/n] => p for positive, n for negative

    // [p/s] => p for prefix, s for suffix

    // [o/p] => o for escaped custom override string, p for pattern string

    UnicodeString ppo = AffixUtils::escape(properties.positivePrefix);

    UnicodeString pso = AffixUtils::escape(properties.positiveSuffix);

    UnicodeString npo = AffixUtils::escape(properties.negativePrefix);

    UnicodeString nso = AffixUtils::escape(properties.negativeSuffix);

    const UnicodeString& ppp = properties.positivePrefixPattern;

    const UnicodeString& psp = properties.positiveSuffixPattern;

    const UnicodeString& npp = properties.negativePrefixPattern;

    const UnicodeString& nsp = properties.negativeSuffixPattern;

    if (!properties.positivePrefix.isBogus()) {

        posPrefix = ppo;

    } else if (!ppp.isBogus()) {

        posPrefix = ppp;

    } else {

        // UTS 35: Default positive prefix is empty string.

        posPrefix = u"";

    }

    if (!properties.positiveSuffix.isBogus()) {

        posSuffix = pso;

    } else if (!psp.isBogus()) {

        posSuffix = psp;

    } else {

        // UTS 35: Default positive suffix is empty string.

        posSuffix = u"";

    }

    if (!properties.negativePrefix.isBogus()) {

        negPrefix = npo;

    } else if (!npp.isBogus()) {

        negPrefix = npp;

    } else {

        // UTS 35: Default negative prefix is "-" with positive prefix.

        // Important: We prepend the "-" to the pattern, not the override!

        negPrefix = ppp.isBogus() ? u"-" : u"-" + ppp;

    }

    if (!properties.negativeSuffix.isBogus()) {

        negSuffix = nso;

    } else if (!nsp.isBogus()) {

        negSuffix = nsp;

    } else {

        // UTS 35: Default negative prefix is the positive prefix.

        negSuffix = psp.isBogus() ? u"" : psp;

    }

    // For declaring if this is a currency pattern, we need to look at the

    // original pattern, not at any user-specified overrides.

    isCurrencyPattern = (

        AffixUtils::hasCurrencySymbols(ppp, status) ||

        AffixUtils::hasCurrencySymbols(psp, status) ||

        AffixUtils::hasCurrencySymbols(npp, status) ||

        AffixUtils::hasCurrencySymbols(nsp, status) ||

        properties.currencyAsDecimal);

    fCurrencyAsDecimal = properties.currencyAsDecimal;

}

char16_t PropertiesAffixPatternProvider::charAt(int flags, int i) const {

    return getStringInternal(flags).charAt(i);

}

int PropertiesAffixPatternProvider::length(int flags) const {

    return getStringInternal(flags).length();

}

UnicodeString PropertiesAffixPatternProvider::getString(int32_t flags) const {

    return getStringInternal(flags);

}

const UnicodeString& PropertiesAffixPatternProvider::getStringInternal(int32_t flags) const {

    bool prefix = (flags & AFFIX_PREFIX) != 0;

    bool negative = (flags & AFFIX_NEGATIVE_SUBPATTERN) != 0;

    if (prefix && negative) {

        return negPrefix;

    } else if (prefix) {

        return posPrefix;

    } else if (negative) {

        return negSuffix;

    } else {

        return posSuffix;

    }

}

bool PropertiesAffixPatternProvider::positiveHasPlusSign() const {

    // TODO: Change the internal APIs to propagate out the error?

    ErrorCode localStatus;

    return AffixUtils::containsType(posPrefix, TYPE_PLUS_SIGN, localStatus) ||

           AffixUtils::containsType(posSuffix, TYPE_PLUS_SIGN, localStatus);

}

bool PropertiesAffixPatternProvider::hasNegativeSubpattern() const {

    return (

        (negSuffix != posSuffix) ||

        negPrefix.tempSubString(1) != posPrefix ||

        negPrefix.charAt(0) != u'-'

    );

}

bool PropertiesAffixPatternProvider::negativeHasMinusSign() const {

    ErrorCode localStatus;

    return AffixUtils::containsType(negPrefix, TYPE_MINUS_SIGN, localStatus) ||

           AffixUtils::containsType(negSuffix, TYPE_MINUS_SIGN, localStatus);

}

bool PropertiesAffixPatternProvider::hasCurrencySign() const {

    return isCurrencyPattern;

}

bool PropertiesAffixPatternProvider::containsSymbolType(AffixPatternType type, UErrorCode& status) const {

    return AffixUtils::containsType(posPrefix, type, status) ||

           AffixUtils::containsType(posSuffix, type, status) ||

           AffixUtils::containsType(negPrefix, type, status) ||

           AffixUtils::containsType(negSuffix, type, status);

}

bool PropertiesAffixPatternProvider::hasBody() const {

    return true;

}

bool PropertiesAffixPatternProvider::currencyAsDecimal() const {

    return fCurrencyAsDecimal;

}

void CurrencyPluralInfoAffixProvider::setTo(const CurrencyPluralInfo& cpi,

                                            const DecimalFormatProperties& properties,

                                            UErrorCode& status) {

    // We need to use a PropertiesAffixPatternProvider, not the simpler version ParsedPatternInfo,

    // because user-specified affix overrides still need to work.

    fBogus = false;

    DecimalFormatProperties pluralProperties(properties);

    for (int32_t plural = 0; plural < StandardPlural::COUNT; plural++) {

        const char* keyword = StandardPlural::getKeyword(static_cast<StandardPlural::Form>(plural));

        UnicodeString patternString;

        patternString = cpi.getCurrencyPluralPattern(keyword, patternString);

        PatternParser::parseToExistingProperties(

                patternString,

                pluralProperties,

                IGNORE_ROUNDING_NEVER,

                status);

        affixesByPlural[plural].setTo(pluralProperties, status);

    }

}

char16_t CurrencyPluralInfoAffixProvider::charAt(int32_t flags, int32_t i) const {

    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);

    return affixesByPlural[pluralOrdinal].charAt(flags, i);

}

int32_t CurrencyPluralInfoAffixProvider::length(int32_t flags) const {

    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);

    return affixesByPlural[pluralOrdinal].length(flags);

}

UnicodeString CurrencyPluralInfoAffixProvider::getString(int32_t flags) const {

    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);

    return affixesByPlural[pluralOrdinal].getString(flags);

}

bool CurrencyPluralInfoAffixProvider::positiveHasPlusSign() const {

    return affixesByPlural[StandardPlural::OTHER].positiveHasPlusSign();

}

bool CurrencyPluralInfoAffixProvider::hasNegativeSubpattern() const {

    return affixesByPlural[StandardPlural::OTHER].hasNegativeSubpattern();

}

bool CurrencyPluralInfoAffixProvider::negativeHasMinusSign() const {

    return affixesByPlural[StandardPlural::OTHER].negativeHasMinusSign();

}

bool CurrencyPluralInfoAffixProvider::hasCurrencySign() const {

    return affixesByPlural[StandardPlural::OTHER].hasCurrencySign();

}

bool CurrencyPluralInfoAffixProvider::containsSymbolType(AffixPatternType type, UErrorCode& status) const {

    return affixesByPlural[StandardPlural::OTHER].containsSymbolType(type, status);

}

bool CurrencyPluralInfoAffixProvider::hasBody() const {

    return affixesByPlural[StandardPlural::OTHER].hasBody();

}

bool CurrencyPluralInfoAffixProvider::currencyAsDecimal() const {

    return affixesByPlural[StandardPlural::OTHER].currencyAsDecimal();

}

#endif /* #if !UCONFIG_NO_FORMATTING */