/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#include "ICUFormatNumberFunctor.hpp"


#include <algorithm>


#include <xalanc/ICUBridge/ICUBridge.hpp>


#include <xalanc/Include/XalanAutoPtr.hpp>


#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/XalanDecimalFormatSymbols.hpp>
#include <xalanc/PlatformSupport/XalanMessageLoader.hpp>


#include <xalanc/XPath/XPathExecutionContext.hpp>


namespace XALAN_CPP_NAMESPACE {


ICUFormatNumberFunctor::ICUFormatNumberFunctor(MemoryManager& theManager) :
    m_decimalFormatCache(theManager),
    m_defaultDecimalFormat(theManager, createDecimalFormat(theManager)),
    m_memoryManager(theManager)
{
}


ICUFormatNumberFunctor*
ICUFormatNumberFunctor::create(MemoryManager& theManager) 
{
    typedef ICUFormatNumberFunctor  ThisType;

    XalanAllocationGuard    theGuard(theManager, theManager.allocate(sizeof(ThisType)));

    ThisType* const     theResult =
        new (theGuard.get()) ThisType(theManager);

    theGuard.release();

    return theResult;
}


ICUFormatNumberFunctor::~ICUFormatNumberFunctor()
{
    using std::for_each;

    for_each(
        m_decimalFormatCache.begin(),
        m_decimalFormatCache.end(),
        DecimalFormatCacheStruct::DecimalFormatDeleteFunctor(m_memoryManager));
}


void
ICUFormatNumberFunctor::operator() (
        XPathExecutionContext&              executionContext,   
        double                              theNumber,
        const XalanDOMString&               thePattern,
        const XalanDecimalFormatSymbols*    theDFS,
        XalanDOMString&                     theResult,
        const XalanNode*                    context,
        const Locator*                      locator) const 
{
    if (!doFormat(theNumber, thePattern, theResult, theDFS))
    {
        const XPathExecutionContext::GetCachedString    theGuard(executionContext);

        executionContext.problem(
            XPathExecutionContext::eXSLTProcessor,
            XPathExecutionContext::eWarning,
            XalanMessageLoader::getMessage(
                theGuard.get(),
                XalanMessages::FormatNumberFailed),
            locator,
            context);
    }       
}


DecimalFormatType * 
ICUFormatNumberFunctor::getCachedDecimalFormat(const XalanDecimalFormatSymbols &theDFS) const
{
    using std::find_if;

    DecimalFormatCacheListType::iterator i =
        find_if(
            m_decimalFormatCache.begin(),
            m_decimalFormatCache.end(),
            DecimalFormatCacheStruct::DecimalFormatFindFunctor(&theDFS));

    if (i == m_decimalFormatCache.end())
    {
        return 0;
    }
    else
    {
        // Let's do a quick check to see if we found the first entry.
        // If so, we don't have to update the cache, so just return the
        // appropriate value...
        const DecimalFormatCacheListType::iterator  theBegin =
            m_decimalFormatCache.begin();

        if (i == theBegin)
        {
            return (*i).m_formatter;
        }
        else
        {
            // Save the formatter, because splice() may invalidate
            // the iterator.
            DecimalFormatType* const    theFormatter = (*i).m_formatter;

            // Move the entry to the beginning the cache
            m_decimalFormatCache.splice(theBegin, m_decimalFormatCache, i);

            return theFormatter;
        }
    }
}


bool
ICUFormatNumberFunctor::doFormat(   
        double                              theNumber,
        const XalanDOMString&               thePattern,
        XalanDOMString&                     theResult,
        const XalanDecimalFormatSymbols*    theDFS) const
{

    if (theDFS == 0)
    {
        return doICUFormat(theNumber, thePattern, theResult);
    }

    XalanDOMString  nonLocalPattern(m_memoryManager);

    UnlocalizePatternFunctor    formatter(*theDFS);

    formatter(thePattern, nonLocalPattern, m_memoryManager);


    DecimalFormatType* const    theFormatter =
        getCachedDecimalFormat(*theDFS);

    if (theFormatter != 0)
    {
        return doICUFormat(
                    theNumber,
                    nonLocalPattern,
                    theResult,
                    theFormatter);
    }
    else
    {
        DFAutoPtrType   theDecimalFormatGuard(
                            m_memoryManager,
                            createDecimalFormat(*theDFS, m_memoryManager));

        if (theDecimalFormatGuard.get() != 0)
        {
            // OK, there was no error, so cache the instance...
            cacheDecimalFormat(theDecimalFormatGuard.get(), *theDFS);

            // Release the collator, since it's in the cache and
            // will be controlled by the cache...
            DecimalFormatType* const    theDecimalFormat =
                theDecimalFormatGuard.releasePtr();

            return doICUFormat(
                        theNumber,
                        nonLocalPattern,
                        theResult,
                        theDecimalFormat);
        }
        else
        {
            return doICUFormat(theNumber,nonLocalPattern,theResult);
        }
    }
}


DecimalFormatType*
ICUFormatNumberFunctor::createDecimalFormat(
        const XalanDecimalFormatSymbols&    theXalanDFS,
        MemoryManager&                      theManager)
{
    UErrorCode theStatus = U_ZERO_ERROR;    

    // Use a XalanAutoPtr, to keep this safe until we construct the DecimalFormat instance.
    XalanAutoPtr<icu::DecimalFormatSymbols>  theDFS(new icu::DecimalFormatSymbols(theStatus));
    // We got a XalanDecimalFormatSymbols, so set the
    // corresponding data in the ICU DecimalFormatSymbols.
    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kZeroDigitSymbol,
        UChar(theXalanDFS.getZeroDigit()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kGroupingSeparatorSymbol,
        UChar(theXalanDFS.getGroupingSeparator()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kDecimalSeparatorSymbol,
        UChar(theXalanDFS.getDecimalSeparator()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kPerMillSymbol,
        UChar(theXalanDFS.getPerMill()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kPercentSymbol,
        UChar(theXalanDFS.getPercent()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kDigitSymbol,
        UChar(theXalanDFS.getDigit()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kPatternSeparatorSymbol,
        UChar(theXalanDFS.getPatternSeparator()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kInfinitySymbol,
        ICUBridge::XalanDOMStringToUnicodeString(
            theManager,
            theXalanDFS.getInfinity()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kNaNSymbol,
        ICUBridge::XalanDOMStringToUnicodeString(
            theManager,
            theXalanDFS.getNaN()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kMinusSignSymbol,
        UChar(theXalanDFS.getMinusSign()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kCurrencySymbol,
        ICUBridge::XalanDOMStringToUnicodeString(
            theManager,
            theXalanDFS.getCurrencySymbol()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kIntlCurrencySymbol,
        ICUBridge::XalanDOMStringToUnicodeString(
            theManager,
            theXalanDFS.getInternationalCurrencySymbol()));

    theDFS->setSymbol(
        icu::DecimalFormatSymbols::kMonetarySeparatorSymbol,
        UChar(theXalanDFS.getMonetaryDecimalSeparator()));

    // Construct a DecimalFormat instance.
    DecimalFormatType*  theFormatter = 0;

    XalanConstruct(
        theManager,
        theFormatter,
        theStatus);

    // Guard this, just in case something happens before
    // we return it. 
    DFAutoPtrType   theGuard(theManager, theFormatter);

    if (U_SUCCESS(theStatus))
    {
        // Note that we release the XalanAutoPtr, since the
        // DecimalFormat will adopt the DecimalFormatSymbols instance.
        theGuard->adoptDecimalFormatSymbols(theDFS.release());

        return theGuard.releasePtr();
    } 
    else 
    {
        assert(false);

        return 0;
    }
}


void
ICUFormatNumberFunctor::cacheDecimalFormat(
    DecimalFormatType *                     theFormatter,
    const XalanDecimalFormatSymbols&        theDFS) const
{

    assert(theFormatter != 0);

    // Is the cache full?
    if (m_decimalFormatCache.size() == eCacheMax)
    {
        // Yes, so guard the collator instance, in case pop_back() throws...
        DFAutoPtrType   theDecimalFormatGuard(
                            m_memoryManager,
                            m_decimalFormatCache.back().m_formatter);

        m_decimalFormatCache.pop_back();
    }

    const DecimalFormatCacheListType::value_type    emptyDFC(m_memoryManager);

    m_decimalFormatCache.push_front(emptyDFC);

    DecimalFormatCacheListType::value_type&     theEntry = 
        m_decimalFormatCache.front();

    theEntry.m_formatter = theFormatter;
    theEntry.m_DFS = theDFS;
}


bool
ICUFormatNumberFunctor::doICUFormat(
        double                              theNumber,
        const XalanDOMString&               thePattern,
        XalanDOMString&                     theResult,
        DecimalFormatType*                  theFormatter) const
{
    UErrorCode theStatus = U_ZERO_ERROR;

    if (theFormatter == 0)
    {
        if (m_defaultDecimalFormat.get() != 0) 
        {
            theFormatter = m_defaultDecimalFormat.get();
        }
        else
        {
            return false;
        }
    }

    theFormatter->applyPattern(
        ICUBridge::XalanDOMStringToUnicodeString(m_memoryManager, thePattern),
        theStatus);

    if (U_SUCCESS(theStatus))
    {
        // Do the format...
        icu::UnicodeString   theUnicodeResult;
        theFormatter->format(theNumber, theUnicodeResult);
        ICUBridge::UnicodeStringToXalanDOMString(theUnicodeResult, theResult);
    }

    return U_SUCCESS(theStatus) ? true : false;
}

XalanDOMString&
ICUFormatNumberFunctor::UnlocalizePatternFunctor::operator()(
            const XalanDOMString&   thePattern,
            XalanDOMString&         theResult,
            MemoryManager&          theManager) const
{

    XalanDecimalFormatSymbols   defaultDFS(theManager);

    XalanDOMString::const_iterator iterator = thePattern.begin();

    while( iterator != thePattern.end())
    {
        
        if( m_DFS.getDecimalSeparator() == *iterator )
        {
            theResult.push_back(defaultDFS.getDecimalSeparator());
        }
        else if(m_DFS.getDigit() == *iterator)
        {
            theResult.push_back(defaultDFS.getDigit());
        }
        else if(m_DFS.getGroupingSeparator() == *iterator)
        {
            theResult.push_back(defaultDFS.getGroupingSeparator());
        }
        else if(m_DFS.getMinusSign() == *iterator)
        {
            theResult.push_back(defaultDFS.getMinusSign());
        }
        else if(m_DFS.getPatternSeparator() == *iterator)
        {
            theResult.push_back(defaultDFS.getPatternSeparator());
        }
        else if(m_DFS.getPercent() == *iterator)
        {
            theResult.push_back(defaultDFS.getPercent());
        }
        else if(m_DFS.getPerMill() == *iterator)
        {
            theResult.push_back(defaultDFS.getPerMill());
        }
        else if(m_DFS.getZeroDigit() == *iterator)
        {
            theResult.push_back(defaultDFS.getZeroDigit());
        }
        else
        {   
            switch(*iterator)
            {
            case XalanUnicode::charFullStop:
            case XalanUnicode::charNumberSign:
            case XalanUnicode::charComma:
            case XalanUnicode::charHyphenMinus:
            case XalanUnicode::charSemicolon:
            case XalanUnicode::charPercentSign:
            case XalanUnicode::charPerMilleSign:
            case XalanUnicode::charDigit_0:
                {
                    theResult.push_back(XalanUnicode::charAmpersand);
                    theResult.push_back(*iterator);
                    theResult.push_back(XalanUnicode::charAmpersand);
                }
            }
        }

        iterator++;
    }

    return theResult;
}

}