/*
********************************************************************************
*   Copyright (C) 2015, International Business Machines
*   Corporation and others.  All Rights Reserved.
********************************************************************************
*
* File decimfmtimpl.h
********************************************************************************
*/

#ifndef DECIMFMTIMPL_H
#define DECIMFMTIMPL_H

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/decimfmt.h"
#include "unicode/uobject.h"
#include "affixpatternparser.h"
#include "digitaffixesandpadding.h"
#include "digitformatter.h"
#include "digitgrouping.h"
#include "precision.h"

U_NAMESPACE_BEGIN

class UnicodeString;
class FieldPosition;
class ValueFormatter;
class FieldPositionHandler;
class FixedDecimal;

/**
 * DecimalFormatImpl is the glue code between the legacy DecimalFormat class
 * and the new decimal formatting classes. DecimalFormat still handles
 * parsing directly. However, DecimalFormat uses attributes of this class
 * for parsing when possible.
 *
 * The public API of this class closely mirrors the legacy API of the
 * legacy DecimalFormat deviating only when the legacy API does not make
 * sense. For example, although DecimalFormat has a
 * getPadCharacterString() method, DecimalFormatImpl has a getPadCharacter()
 * method because formatting uses only a single pad character for padding.
 *
 * Each legacy DecimalFormat instance heap allocates its own instance of
 * this class. Most DecimalFormat methods that deal with formatting simply
 * delegate to the DecimalFormat's DecimalFormatImpl method.
 *
 * Because DecimalFormat extends NumberFormat, Each instance of this class
 * "borrows" a pointer to the NumberFormat part of its enclosing DecimalFormat
 * instance. This way each DecimalFormatImpl instance can read or even modify
 * the NumberFormat portion of its enclosing DecimalFormat instance.
 *
 * Directed acyclic graph (DAG):
 *
 * This class can be represented as a directed acyclic graph (DAG) where each
 * vertex is an attribute, and each directed edge indicates that the value
 * of the destination attribute is calculated from the value of the source
 * attribute. Attributes with setter methods reside at the bottom of the
 * DAG. That is, no edges point to them. We call these independent attributes
 * because their values can be set independently of one another. The rest of
 * the attributes are derived attributes because their values depend on the
 * independent attributes. DecimalFormatImpl often uses the derived
 * attributes, not the independent attributes, when formatting numbers.
 *
 * The independent attributes at the bottom of the DAG correspond to the legacy
 * attributes of DecimalFormat while the attributes at the top of the DAG
 * correspond to the attributes of the new code. The edges of the DAG
 * correspond to the code that handles the complex interaction among all the
 * legacy attributes of the DecimalFormat API.
 *
 * We use a DAG for three reasons.
 *
 * First, the DAG preserves backward compatibility. Clients of the legacy
 * DecimalFormat expect existing getters and setters of each attribute to be
 * consistent. That means if a client sets a particular attribute to a new
 * value, the attribute should retain that value until the client sets it to
 * a new value. The DAG allows these attributes to remain consistent even
 * though the new code may not use them when formatting.
 *
 * Second, the DAG obviates the need to recalculate derived attributes with
 * each format. Instead, the DAG "remembers" the values of all derived
 * attributes. Only setting an independent attribute requires a recalculation.
 * Moreover, setting an independent attribute recalculates only the affected
 * dependent attributes rather than all dependent attributes.
 *
 * Third, the DAG abstracts away the complex interaction among the legacy
 * attributes of the DecimalFormat API.
 *
 * Only the independent attributes of the DAG have setters and getters.
 * Derived attributes have no setters (and often no getters either).
 *
 * Copy and assign:
 *
 * For copy and assign, DecimalFormatImpl copies and assigns every attribute
 * regardless of whether or not it is independent. We do this for simplicity.
 *
 * Implementation of the DAG:
 *
 * The DAG consists of three smaller DAGs:
 * 1. Grouping attributes
 * 2. Precision attributes
 * 3. Formatting attributes.
 *
 * The first two DAGs are simple in that setting any independent attribute
 * in the DAG recalculates all the dependent attributes in that DAG.
 * The updateGrouping() and updatePrecision() perform the respective
 * recalculations. 
 *
 * Because some of the derived formatting attributes are expensive to
 * calculate, the formatting attributes DAG is more complex. The
 * updateFormatting() method is composed of many updateFormattingXXX()
 * methods, each of which recalculates a single derived attribute. The
 * updateFormatting() method accepts a bitfield of recently changed
 * attributes and passes this bitfield by reference to each of the
 * updateFormattingXXX() methods. Each updateFormattingXXX() method checks
 * the bitfield to see if any of the attributes it uses to compute the XXX
 * attribute changed. If none of them changed, it exists immediately. However,
 * if at least one of them changed, it recalculates the XXX attribute and
 * sets the corresponding bit in the bitfield. In this way, each
 * updateFormattingXXX() method encodes the directed edges in the formatting
 * DAG that point to the attribute its calculating.
 *
 * Maintenance of the updateFormatting() method.
 *
 * Use care when changing the updateFormatting() method.
 * The updateFormatting() method must call each updateFormattingXXX() in the
 * same partial order that the formatting DAG prescribes. That is, the
 * attributes near the bottom of the DAG must be calculated before attributes
 * further up. As we mentioned in the prvious paragraph, the directed edges of
 * the formatting DAG are encoded within each updateFormattingXXX() method.
 * Finally, adding new attributes may involve adding to the bitmap that the
 * updateFormatting() method uses. The top most attributes in the DAG,
 * those that do not point to any attributes but only have attributes
 * pointing to it, need not have a slot in the bitmap.
 *
 * Keep in mind that most of the code that makes the legacy DecimalFormat API
 * work the way it always has before can be found in these various updateXXX()
 * methods. For example the updatePrecisionForScientific() method
 * handles the complex interactions amoung the various precision attributes
 * when formatting in scientific notation. Changing the way attributes
 * interract, often means changing one of these updateXXX() methods.
 *
 * Conclusion:
 *
 * The DecimFmtImpl class is the glue code between the legacy and new
 * number formatting code. It uses a direct acyclic graph (DAG) to
 * maintain backward compatibility, to make the code efficient, and to
 * abstract away the complex interraction among legacy attributs.
 */


class DecimalFormatImpl : public UObject {
public:

DecimalFormatImpl(
        NumberFormat *super,
        const Locale &locale,
        const UnicodeString &pattern,
        UErrorCode &status);
DecimalFormatImpl(
        NumberFormat *super,
        const UnicodeString &pattern,
        DecimalFormatSymbols *symbolsToAdopt,
        UParseError &parseError,
        UErrorCode &status);
DecimalFormatImpl(
        NumberFormat *super,
        const DecimalFormatImpl &other,
        UErrorCode &status);
DecimalFormatImpl &assign(
        const DecimalFormatImpl &other, UErrorCode &status);
virtual ~DecimalFormatImpl();
void adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt);
const DecimalFormatSymbols &getDecimalFormatSymbols() const {
    return *fSymbols;
}
UnicodeString &format(
        int32_t number,
        UnicodeString &appendTo,
        FieldPosition &pos,
        UErrorCode &status) const;
UnicodeString &format(
        int32_t number,
        UnicodeString &appendTo,
        FieldPositionIterator *posIter,
        UErrorCode &status) const;
UnicodeString &format(
        int64_t number,
        UnicodeString &appendTo,
        FieldPosition &pos,
        UErrorCode &status) const;
UnicodeString &format(
        double number,
        UnicodeString &appendTo,
        FieldPosition &pos,
        UErrorCode &status) const;
UnicodeString &format(
        const DigitList &number,
        UnicodeString &appendTo,
        FieldPosition &pos,
        UErrorCode &status) const;
UnicodeString &format(
        int64_t number,
        UnicodeString &appendTo,
        FieldPositionIterator *posIter,
        UErrorCode &status) const;
UnicodeString &format(
        double number,
        UnicodeString &appendTo,
        FieldPositionIterator *posIter,
        UErrorCode &status) const;
UnicodeString &format(
        const DigitList &number,
        UnicodeString &appendTo,
        FieldPositionIterator *posIter,
        UErrorCode &status) const;
UnicodeString &format(
        const StringPiece &number,
        UnicodeString &appendTo,
        FieldPositionIterator *posIter,
        UErrorCode &status) const;
UnicodeString &format(
        const VisibleDigitsWithExponent &digits,
        UnicodeString &appendTo,
        FieldPosition &pos,
        UErrorCode &status) const;
UnicodeString &format(
        const VisibleDigitsWithExponent &digits,
        UnicodeString &appendTo,
        FieldPositionIterator *posIter,
        UErrorCode &status) const;

UBool operator==(const DecimalFormatImpl &) const;

UBool operator!=(const DecimalFormatImpl &other) const {
    return !(*this == other);
}

void setRoundingMode(DecimalFormat::ERoundingMode mode) {
    fRoundingMode = mode;
    fEffPrecision.fMantissa.fExactOnly = (fRoundingMode == DecimalFormat::kRoundUnnecessary);
    fEffPrecision.fMantissa.fRoundingMode = mode;
}
DecimalFormat::ERoundingMode getRoundingMode() const {
    return fRoundingMode;
}
void setFailIfMoreThanMaxDigits(UBool b) {
    fEffPrecision.fMantissa.fFailIfOverMax = b;
}
UBool isFailIfMoreThanMaxDigits() const { return fEffPrecision.fMantissa.fFailIfOverMax; }
void setMinimumSignificantDigits(int32_t newValue);
void setMaximumSignificantDigits(int32_t newValue);
void setMinMaxSignificantDigits(int32_t min, int32_t max);
void setScientificNotation(UBool newValue);
void setSignificantDigitsUsed(UBool newValue);

int32_t getMinimumSignificantDigits() const { 
        return fMinSigDigits; }
int32_t getMaximumSignificantDigits() const { 
        return fMaxSigDigits; }
UBool isScientificNotation() const { return fUseScientific; }
UBool areSignificantDigitsUsed() const { return fUseSigDigits; }
void setGroupingSize(int32_t newValue);
void setSecondaryGroupingSize(int32_t newValue);
void setMinimumGroupingDigits(int32_t newValue);
int32_t getGroupingSize() const { return fGrouping.fGrouping; }
int32_t getSecondaryGroupingSize() const { return fGrouping.fGrouping2; }
int32_t getMinimumGroupingDigits() const { return fGrouping.fMinGrouping; }
void applyPattern(const UnicodeString &pattern, UErrorCode &status);
void applyPatternFavorCurrencyPrecision(
        const UnicodeString &pattern, UErrorCode &status);
void applyPattern(
        const UnicodeString &pattern, UParseError &perror, UErrorCode &status);
void applyLocalizedPattern(const UnicodeString &pattern, UErrorCode &status);
void applyLocalizedPattern(
        const UnicodeString &pattern, UParseError &perror, UErrorCode &status);
void setCurrencyUsage(UCurrencyUsage usage, UErrorCode &status);
UCurrencyUsage getCurrencyUsage() const { return fCurrencyUsage; }
void setRoundingIncrement(double d);
double getRoundingIncrement() const;
int32_t getMultiplier() const;
void setMultiplier(int32_t m);
UChar32 getPadCharacter() const { return fAffixes.fPadChar; }
void setPadCharacter(UChar32 c) { fAffixes.fPadChar = c; }
int32_t getFormatWidth() const { return fAffixes.fWidth; }
void setFormatWidth(int32_t x) { fAffixes.fWidth = x; }
DigitAffixesAndPadding::EPadPosition getPadPosition() const {
    return fAffixes.fPadPosition;
}
void setPadPosition(DigitAffixesAndPadding::EPadPosition x) {
    fAffixes.fPadPosition = x;
}
int32_t getMinimumExponentDigits() const {
    return fEffPrecision.fMinExponentDigits;
}
void setMinimumExponentDigits(int32_t x) {
    fEffPrecision.fMinExponentDigits = x;
}
UBool isExponentSignAlwaysShown() const {
    return fOptions.fExponent.fAlwaysShowSign;
}
void setExponentSignAlwaysShown(UBool x) {
    fOptions.fExponent.fAlwaysShowSign = x;
}
UBool isDecimalSeparatorAlwaysShown() const {
    return fOptions.fMantissa.fAlwaysShowDecimal;
}
void setDecimalSeparatorAlwaysShown(UBool x) {
    fOptions.fMantissa.fAlwaysShowDecimal = x;
}
UnicodeString &getPositivePrefix(UnicodeString &result) const;
UnicodeString &getPositiveSuffix(UnicodeString &result) const;
UnicodeString &getNegativePrefix(UnicodeString &result) const;
UnicodeString &getNegativeSuffix(UnicodeString &result) const;
void setPositivePrefix(const UnicodeString &str);
void setPositiveSuffix(const UnicodeString &str);
void setNegativePrefix(const UnicodeString &str);
void setNegativeSuffix(const UnicodeString &str);
UnicodeString &toPattern(UnicodeString& result) const;
FixedDecimal &getFixedDecimal(double value, FixedDecimal &result, UErrorCode &status) const;
FixedDecimal &getFixedDecimal(DigitList &number, FixedDecimal &result, UErrorCode &status) const;
DigitList &round(DigitList &number, UErrorCode &status) const;

VisibleDigitsWithExponent &
initVisibleDigitsWithExponent(
        int64_t number,
        VisibleDigitsWithExponent &digits,
        UErrorCode &status) const;
VisibleDigitsWithExponent &
initVisibleDigitsWithExponent(
        double number,
        VisibleDigitsWithExponent &digits,
        UErrorCode &status) const;
VisibleDigitsWithExponent &
initVisibleDigitsWithExponent(
        DigitList &number,
        VisibleDigitsWithExponent &digits,
        UErrorCode &status) const;

void updatePrecision();
void updateGrouping();
void updateCurrency(UErrorCode &status);


private:
// Disallow copy and assign
DecimalFormatImpl(const DecimalFormatImpl &other);
DecimalFormatImpl &operator=(const DecimalFormatImpl &other);
NumberFormat *fSuper;
DigitList fMultiplier;
int32_t fScale;

DecimalFormat::ERoundingMode fRoundingMode;

// These fields include what the user can see and set.
// When the user updates these fields, it triggers automatic updates of
// other fields that may be invisible to user

// Updating any of the following fields triggers an update to
// fEffPrecision.fMantissa.fMin,
// fEffPrecision.fMantissa.fMax,
// fEffPrecision.fMantissa.fSignificant fields
// We have this two phase update because of backward compatibility. 
// DecimalFormat has to remember all settings even if those settings are
// invalid or disabled.
int32_t fMinSigDigits;
int32_t fMaxSigDigits;
UBool fUseScientific;
UBool fUseSigDigits;
// In addition to these listed above, changes to min/max int digits and
// min/max frac digits from fSuper also trigger an update.

// Updating any of the following fields triggers an update to
// fEffGrouping field Again we do it this way because original
// grouping settings have to be retained if grouping is turned off.
DigitGrouping fGrouping;
// In addition to these listed above, changes to isGroupingUsed in
// fSuper also triggers an update to fEffGrouping.

// Updating any of the following fields triggers updates on the following:
// fMonetary, fRules, fAffixParser, fCurrencyAffixInfo,
// fFormatter, fAffixes.fPositivePrefiix, fAffixes.fPositiveSuffix,
// fAffixes.fNegativePrefiix, fAffixes.fNegativeSuffix
// We do this two phase update because localizing the affix patterns
// and formatters can be expensive. Better to do it once with the setters
// than each time within format.
AffixPattern fPositivePrefixPattern;
AffixPattern fNegativePrefixPattern;
AffixPattern fPositiveSuffixPattern;
AffixPattern fNegativeSuffixPattern;
DecimalFormatSymbols *fSymbols;
UCurrencyUsage fCurrencyUsage;
// In addition to these listed above, changes to getCurrency() in
// fSuper also triggers an update.

// Optional may be NULL
PluralRules *fRules;

// These fields are totally hidden from user and are used to derive the affixes
// in fAffixes below from the four affix patterns above.
UBool fMonetary;
AffixPatternParser fAffixParser;
CurrencyAffixInfo fCurrencyAffixInfo;

// The actual precision used when formatting
ScientificPrecision fEffPrecision;

// The actual grouping used when formatting
DigitGrouping fEffGrouping;
SciFormatterOptions fOptions;   // Encapsulates fixed precision options
DigitFormatter fFormatter;
DigitAffixesAndPadding fAffixes;

UnicodeString &formatInt32(
        int32_t number,
        UnicodeString &appendTo,
        FieldPositionHandler &handler,
        UErrorCode &status) const;

UnicodeString &formatInt64(
        int64_t number,
        UnicodeString &appendTo,
        FieldPositionHandler &handler,
        UErrorCode &status) const;

UnicodeString &formatDouble(
        double number,
        UnicodeString &appendTo,
        FieldPositionHandler &handler,
        UErrorCode &status) const;

// Scales for precent or permille symbols
UnicodeString &formatDigitList(
        DigitList &number,
        UnicodeString &appendTo,
        FieldPositionHandler &handler,
        UErrorCode &status) const;

// Does not scale for precent or permille symbols
UnicodeString &formatAdjustedDigitList(
        DigitList &number,
        UnicodeString &appendTo,
        FieldPositionHandler &handler,
        UErrorCode &status) const;

UnicodeString &formatVisibleDigitsWithExponent(
        const VisibleDigitsWithExponent &number,
        UnicodeString &appendTo,
        FieldPositionHandler &handler,
        UErrorCode &status) const;

VisibleDigitsWithExponent &
initVisibleDigitsFromAdjusted(
        DigitList &number,
        VisibleDigitsWithExponent &digits,
        UErrorCode &status) const;

template<class T>
UBool maybeFormatWithDigitList(
        T number,
        UnicodeString &appendTo,
        FieldPositionHandler &handler,
        UErrorCode &status) const;

template<class T>
UBool maybeInitVisibleDigitsFromDigitList(
        T number,
        VisibleDigitsWithExponent &digits,
        UErrorCode &status) const;

DigitList &adjustDigitList(DigitList &number, UErrorCode &status) const;

void applyPattern(
        const UnicodeString &pattern,
        UBool localized, UParseError &perror, UErrorCode &status);

ValueFormatter &prepareValueFormatter(ValueFormatter &vf) const;
void setMultiplierScale(int32_t s);
int32_t getPatternScale() const;
void setScale(int32_t s) { fScale = s; }
int32_t getScale() const { return fScale; }

// Updates everything
void updateAll(UErrorCode &status);
void updateAll(
        int32_t formattingFlags,
        UBool updatePrecisionBasedOnCurrency,
        UErrorCode &status);

// Updates from formatting pattern changes
void updateForApplyPattern(UErrorCode &status);
void updateForApplyPatternFavorCurrencyPrecision(UErrorCode &status);

// Updates from changes to third group of attributes
void updateFormatting(int32_t changedFormattingFields, UErrorCode &status);
void updateFormatting(
        int32_t changedFormattingFields,
        UBool updatePrecisionBasedOnCurrency,
        UErrorCode &status);

// Helper functions for updatePrecision
void updatePrecisionForScientific();
void updatePrecisionForFixed();
void extractMinMaxDigits(DigitInterval &min, DigitInterval &max) const;
void extractSigDigits(SignificantDigitInterval &sig) const;

// Helper functions for updateFormatting
void updateFormattingUsesCurrency(int32_t &changedFormattingFields);
void updateFormattingPluralRules(
        int32_t &changedFormattingFields, UErrorCode &status);
void updateFormattingAffixParser(int32_t &changedFormattingFields);
void updateFormattingCurrencyAffixInfo(
        int32_t &changedFormattingFields,
        UBool updatePrecisionBasedOnCurrency,
        UErrorCode &status);
void updateFormattingFixedPointFormatter(
        int32_t &changedFormattingFields);
void updateFormattingLocalizedPositivePrefix(
        int32_t &changedFormattingFields, UErrorCode &status);
void updateFormattingLocalizedPositiveSuffix(
        int32_t &changedFormattingFields, UErrorCode &status);
void updateFormattingLocalizedNegativePrefix(
        int32_t &changedFormattingFields, UErrorCode &status);
void updateFormattingLocalizedNegativeSuffix(
        int32_t &changedFormattingFields, UErrorCode &status);

int32_t computeExponentPatternLength() const;
int32_t countFractionDigitAndDecimalPatternLength(int32_t fracDigitCount) const;
UnicodeString &toNumberPattern(
        UBool hasPadding, int32_t minimumLength, UnicodeString& result) const;

int32_t getOldFormatWidth() const;
const UnicodeString &getConstSymbol(
        DecimalFormatSymbols::ENumberFormatSymbol symbol) const;
UBool isParseFastpath() const;

friend class DecimalFormat;

};


U_NAMESPACE_END
#endif /* #if !UCONFIG_NO_FORMATTING */
#endif // DECIMFMTIMPL_H
//eof