/*
 * Copyright 2003, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2010-2011, Oliver Tappe, zooey@hirschkaefer.de.
 * Copyright 2012, John Scipione, jscipione@gmail.com
 * Copyright 2017, Adrien Destugues, pulkomandy@pulkomandy.tk
 * Copyright 2021, Andrew Lindesay, apl@lindesay.co.nz
 * All rights reserved. Distributed under the terms of the MIT License.
 */


#include <unicode/uversion.h>
#include <NumberFormat.h>

#include <AutoDeleter.h>
#include <Autolock.h>
#include <FormattingConventionsPrivate.h>

#include <ICUWrapper.h>

#include <unicode/dcfmtsym.h>
#include <unicode/decimfmt.h>
#include <unicode/numfmt.h>


U_NAMESPACE_USE


class BNumberFormatImpl {
public:
                                        BNumberFormatImpl();
                                        ~BNumberFormatImpl();

        NumberFormat*   GetInteger(BFormattingConventions* convention);
        NumberFormat*   GetFloat(BFormattingConventions* convention);
        NumberFormat*   GetCurrency(BFormattingConventions* convention);
        NumberFormat*   GetPercent(BFormattingConventions* convention);

        ssize_t                 ApplyFormatter(NumberFormat* formatter, char* string,
                                                size_t maxSize, const double value);
        status_t                ApplyFormatter(NumberFormat* formatter, BString& string,
                                                const double value);

private:
        NumberFormat*   fIntegerFormat;
        NumberFormat*   fFloatFormat;
        NumberFormat*   fCurrencyFormat;
        NumberFormat*   fPercentFormat;
};


BNumberFormatImpl::BNumberFormatImpl()
{
        // They are initialized lazily as needed
        fIntegerFormat = NULL;
        fFloatFormat = NULL;
        fCurrencyFormat = NULL;
        fPercentFormat = NULL;
}


BNumberFormatImpl::~BNumberFormatImpl()
{
        delete fIntegerFormat;
        delete fFloatFormat;
        delete fCurrencyFormat;
        delete fPercentFormat;
}


NumberFormat*
BNumberFormatImpl::GetInteger(BFormattingConventions* convention)
{
        if (fIntegerFormat == NULL) {
                UErrorCode err = U_ZERO_ERROR;
                fIntegerFormat = NumberFormat::createInstance(
                        *BFormattingConventions::Private(convention).ICULocale(),
                        UNUM_DECIMAL, err);

                if (fIntegerFormat == NULL)
                        return NULL;
                if (U_FAILURE(err)) {
                        delete fIntegerFormat;
                        fIntegerFormat = NULL;
                        return NULL;
                }
        }

        return fIntegerFormat;
}


NumberFormat*
BNumberFormatImpl::GetFloat(BFormattingConventions* convention)
{
        if (fFloatFormat == NULL) {
                UErrorCode err = U_ZERO_ERROR;
                fFloatFormat = NumberFormat::createInstance(
                        *BFormattingConventions::Private(convention).ICULocale(),
                        UNUM_DECIMAL, err);

                if (fFloatFormat == NULL)
                        return NULL;
                if (U_FAILURE(err)) {
                        delete fFloatFormat;
                        fFloatFormat = NULL;
                        return NULL;
                }
        }

        return fFloatFormat;
}


NumberFormat*
BNumberFormatImpl::GetCurrency(BFormattingConventions* convention)
{
        if (fCurrencyFormat == NULL) {
                UErrorCode err = U_ZERO_ERROR;
                fCurrencyFormat = NumberFormat::createCurrencyInstance(
                        *BFormattingConventions::Private(convention).ICULocale(),
                        err);

                if (fCurrencyFormat == NULL)
                        return NULL;
                if (U_FAILURE(err)) {
                        delete fCurrencyFormat;
                        fCurrencyFormat = NULL;
                        return NULL;
                }
        }

        return fCurrencyFormat;
}


NumberFormat*
BNumberFormatImpl::GetPercent(BFormattingConventions* convention)
{
        if (fPercentFormat == NULL) {
                UErrorCode err = U_ZERO_ERROR;
                fPercentFormat = NumberFormat::createInstance(
                        *BFormattingConventions::Private(convention).ICULocale(),
                        UNUM_PERCENT, err);

                if (fPercentFormat == NULL)
                        return NULL;
                if (U_FAILURE(err)) {
                        delete fPercentFormat;
                        fPercentFormat = NULL;
                        return NULL;
                }
        }

        return fPercentFormat;
}


ssize_t
BNumberFormatImpl::ApplyFormatter(NumberFormat* formatter, char* string,
        size_t maxSize, const double value)
{
        BString fullString;
        status_t status = ApplyFormatter(formatter, fullString, value);
        if (status != B_OK)
                return status;

        return strlcpy(string, fullString.String(), maxSize);
}


status_t
BNumberFormatImpl::ApplyFormatter(NumberFormat* formatter, BString& string,
        const double value)
{
        if (formatter == NULL)
                return B_NO_MEMORY;

        UnicodeString icuString;
        formatter->format(value, icuString);

        string.Truncate(0);
        BStringByteSink stringConverter(&string);
        icuString.toUTF8(stringConverter);

        return B_OK;
}


BNumberFormat::BNumberFormat()
        : BFormat()
{
        fPrivateData = new BNumberFormatImpl();
}


BNumberFormat::BNumberFormat(const BLocale* locale)
        : BFormat(locale)
{
        fPrivateData = new BNumberFormatImpl();
}


BNumberFormat::BNumberFormat(const BNumberFormat &other)
        : BFormat(other)
{
        fPrivateData = new BNumberFormatImpl(*other.fPrivateData);
}


BNumberFormat::~BNumberFormat()
{
        delete fPrivateData;
}


// #pragma mark - Formatting


ssize_t
BNumberFormat::Format(char* string, size_t maxSize, const double value)
{
        BString fullString;
        status_t status = Format(fullString, value);
        if (status != B_OK)
                return status;

        return strlcpy(string, fullString.String(), maxSize);
}


status_t
BNumberFormat::Format(BString& string, const double value)
{
        NumberFormat* formatter = fPrivateData->GetFloat(&fConventions);

        if (formatter == NULL)
                return B_NO_MEMORY;

        UnicodeString icuString;
        formatter->format(value, icuString);

        string.Truncate(0);
        BStringByteSink stringConverter(&string);
        icuString.toUTF8(stringConverter);

        return B_OK;
}


ssize_t
BNumberFormat::Format(char* string, size_t maxSize, const int32 value)
{
        BString fullString;
        status_t status = Format(fullString, value);
        if (status != B_OK)
                return status;

        return strlcpy(string, fullString.String(), maxSize);
}


status_t
BNumberFormat::Format(BString& string, const int32 value)
{
        NumberFormat* formatter = fPrivateData->GetInteger(&fConventions);

        if (formatter == NULL)
                return B_NO_MEMORY;

        UnicodeString icuString;
        formatter->format((int32_t)value, icuString);

        string.Truncate(0);
        BStringByteSink stringConverter(&string);
        icuString.toUTF8(stringConverter);

        return B_OK;
}


status_t
BNumberFormat::SetPrecision(int precision)
{
        NumberFormat* decimalFormatter = fPrivateData->GetFloat(&fConventions);
        NumberFormat* currencyFormatter = fPrivateData->GetCurrency(&fConventions);
        NumberFormat* percentFormatter = fPrivateData->GetPercent(&fConventions);

        if ((decimalFormatter == NULL) || (currencyFormatter == NULL) || (percentFormatter == NULL))
                return B_ERROR;

        decimalFormatter->setMinimumFractionDigits(precision);
        decimalFormatter->setMaximumFractionDigits(precision);

        currencyFormatter->setMinimumFractionDigits(precision);
        currencyFormatter->setMaximumFractionDigits(precision);

        percentFormatter->setMinimumFractionDigits(precision);
        percentFormatter->setMaximumFractionDigits(precision);

        return B_OK;
}


ssize_t
BNumberFormat::FormatMonetary(char* string, size_t maxSize, const double value)
{
        return fPrivateData->ApplyFormatter(
                fPrivateData->GetCurrency(&fConventions), string, maxSize, value);
}


status_t
BNumberFormat::FormatMonetary(BString& string, const double value)
{
        return fPrivateData->ApplyFormatter(
                fPrivateData->GetCurrency(&fConventions), string, value);
}


ssize_t
BNumberFormat::FormatPercent(char* string, size_t maxSize, const double value)
{
        return fPrivateData->ApplyFormatter(
                fPrivateData->GetPercent(&fConventions), string, maxSize, value);
}


status_t
BNumberFormat::FormatPercent(BString& string, const double value)
{
        return fPrivateData->ApplyFormatter(
                fPrivateData->GetPercent(&fConventions), string, value);
}


status_t
BNumberFormat::Parse(const BString& string, double& value)
{
        NumberFormat* parser = fPrivateData->GetFloat(&fConventions);

        if (parser == NULL)
                return B_NO_MEMORY;

        UnicodeString unicode(string.String());
        Formattable result(0);
        UErrorCode err = U_ZERO_ERROR;

        parser->parse(unicode, result, err);

        if (err != U_ZERO_ERROR)
                return B_BAD_DATA;

        value = result.getDouble();

        return B_OK;
}


BString
BNumberFormat::GetSeparator(BNumberElement element)
{
        DecimalFormatSymbols::ENumberFormatSymbol symbol;
        BString result;

        switch(element) {
                case B_DECIMAL_SEPARATOR:
                        symbol = DecimalFormatSymbols::kDecimalSeparatorSymbol;
                        break;
                case B_GROUPING_SEPARATOR:
                        symbol = DecimalFormatSymbols::kGroupingSeparatorSymbol;
                        break;

                default:
                        return result;
        }

        NumberFormat* format = fPrivateData->GetFloat(&fConventions);
        DecimalFormat* decimal = dynamic_cast<DecimalFormat*>(format);

        if (decimal == NULL)
                return result;

        const DecimalFormatSymbols* symbols = decimal->getDecimalFormatSymbols();
        UnicodeString string = symbols->getSymbol(symbol);

        BStringByteSink stringConverter(&result);
        string.toUTF8(stringConverter);

        return result;
}