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

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

/*

*******************************************************************************

*

*   Copyright (C) 1999-2012, International Business Machines

*   Corporation and others.  All Rights Reserved.

*

*******************************************************************************

*   file name:  umsg.cpp

*   encoding:   UTF-8

*   tab size:   8 (not used)

*   indentation:4

*

* This is a C wrapper to MessageFormat C++ API.

*

*   Change history:

*

*   08/5/2001  Ram         Added C wrappers for C++ API. Changed implementation of old API's

*                          Removed pattern parser.

* 

*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/umsg.h"

#include "unicode/ustring.h"

#include "unicode/fmtable.h"

#include "unicode/msgfmt.h"

#include "unicode/unistr.h"

#include "cpputils.h"

#include "uassert.h"

#include "ustr_imp.h"

U_NAMESPACE_BEGIN

/**

 * This class isolates our access to private internal methods of

 * MessageFormat.  It is never instantiated; it exists only for C++

 * access management.

 */

class MessageFormatAdapter {

public:

    static const Formattable::Type* getArgTypeList(const MessageFormat& m,

                                                   int32_t& count);

    static UBool hasArgTypeConflicts(const MessageFormat& m) {

        return m.hasArgTypeConflicts;

    }

};

const Formattable::Type*

MessageFormatAdapter::getArgTypeList(const MessageFormat& m,

                                     int32_t& count) {

    return m.getArgTypeList(count);

}

U_NAMESPACE_END

U_NAMESPACE_USE

U_CAPI int32_t

u_formatMessage(const char  *locale,

                const UChar *pattern,

                int32_t     patternLength,

                UChar       *result,

                int32_t     resultLength,

                UErrorCode  *status,

                ...)

{

    va_list    ap;

    int32_t actLen;        

    //argument checking deferred to subsequent method calls

    // start vararg processing

    va_start(ap, status);

    actLen = u_vformatMessage(locale,pattern,patternLength,result,resultLength,ap,status);

    // end vararg processing

    va_end(ap);

    return actLen;

}

U_CAPI int32_t U_EXPORT2

u_vformatMessage(   const char  *locale,

                    const UChar *pattern,

                    int32_t     patternLength,

                    UChar       *result,

                    int32_t     resultLength,

                    va_list     ap,

                    UErrorCode  *status)

{

    //argument checking deferred to subsequent method calls

    UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,NULL,status);

    int32_t retVal = umsg_vformat(fmt,result,resultLength,ap,status);

    umsg_close(fmt);

    return retVal;

}

U_CAPI int32_t

u_formatMessageWithError(const char *locale,

                        const UChar *pattern,

                        int32_t     patternLength,

                        UChar       *result,

                        int32_t     resultLength,

                        UParseError *parseError,

                        UErrorCode  *status,

                        ...)

{

    va_list    ap;

    int32_t actLen;

    //argument checking deferred to subsequent method calls

    // start vararg processing

    va_start(ap, status);

    actLen = u_vformatMessageWithError(locale,pattern,patternLength,result,resultLength,parseError,ap,status);

    // end vararg processing

    va_end(ap);

    return actLen;

}

U_CAPI int32_t U_EXPORT2

u_vformatMessageWithError(  const char  *locale,

                            const UChar *pattern,

                            int32_t     patternLength,

                            UChar       *result,

                            int32_t     resultLength,

                            UParseError *parseError,

                            va_list     ap,

                            UErrorCode  *status)

{

    //argument checking deferred to subsequent method calls

    UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,parseError,status);

    int32_t retVal = umsg_vformat(fmt,result,resultLength,ap,status);

    umsg_close(fmt);

    return retVal;

}

// For parse, do the reverse of format:

//  1. Call through to the C++ APIs

//  2. Just assume the user passed in enough arguments.

//  3. Iterate through each formattable returned, and assign to the arguments

U_CAPI void

u_parseMessage( const char   *locale,

                const UChar  *pattern,

                int32_t      patternLength,

                const UChar  *source,

                int32_t      sourceLength,

                UErrorCode   *status,

                ...)

{

    va_list    ap;

    //argument checking deferred to subsequent method calls

    // start vararg processing

    va_start(ap, status);

    u_vparseMessage(locale,pattern,patternLength,source,sourceLength,ap,status);

    // end vararg processing

    va_end(ap);

}

U_CAPI void U_EXPORT2

u_vparseMessage(const char  *locale,

                const UChar *pattern,

                int32_t     patternLength,

                const UChar *source,

                int32_t     sourceLength,

                va_list     ap,

                UErrorCode  *status)

{

    //argument checking deferred to subsequent method calls

    UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,NULL,status);

    int32_t count = 0;

    umsg_vparse(fmt,source,sourceLength,&count,ap,status);

    umsg_close(fmt);

}

U_CAPI void

u_parseMessageWithError(const char  *locale,

                        const UChar *pattern,

                        int32_t     patternLength,

                        const UChar *source,

                        int32_t     sourceLength,

                        UParseError *error,

                        UErrorCode  *status,

                        ...)

{

    va_list    ap;

    //argument checking deferred to subsequent method calls

    // start vararg processing

    va_start(ap, status);

    u_vparseMessageWithError(locale,pattern,patternLength,source,sourceLength,ap,error,status);

    // end vararg processing

    va_end(ap);

}

U_CAPI void U_EXPORT2

u_vparseMessageWithError(const char  *locale,

                         const UChar *pattern,

                         int32_t     patternLength,

                         const UChar *source,

                         int32_t     sourceLength,

                         va_list     ap,

                         UParseError *error,

                         UErrorCode* status)

{

    //argument checking deferred to subsequent method calls

    UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,error,status);

    int32_t count = 0;

    umsg_vparse(fmt,source,sourceLength,&count,ap,status);

    umsg_close(fmt);

}

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

//

//  Message format C API

//

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

U_CAPI UMessageFormat* U_EXPORT2

umsg_open(  const UChar     *pattern,

            int32_t         patternLength,

            const  char     *locale,

            UParseError     *parseError,

            UErrorCode      *status)

{

    //check arguments

    if(status==NULL || U_FAILURE(*status))

    {

      return 0;

    }

    if(pattern==NULL||patternLength<-1){

        *status=U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    UParseError tErr;

    if(parseError==NULL)

    {

        parseError = &tErr;

    }

    int32_t len = (patternLength == -1 ? u_strlen(pattern) : patternLength);

    UnicodeString patString(patternLength == -1, pattern, len);

    MessageFormat* retVal = new MessageFormat(patString,Locale(locale),*parseError,*status);

    if(retVal == NULL) {

        *status = U_MEMORY_ALLOCATION_ERROR;

        return NULL;

    }

    if (U_SUCCESS(*status) && MessageFormatAdapter::hasArgTypeConflicts(*retVal)) {

        *status = U_ARGUMENT_TYPE_MISMATCH;

    }

    return (UMessageFormat*)retVal;

}

U_CAPI void U_EXPORT2

umsg_close(UMessageFormat* format)

{

    //check arguments

    if(format==NULL){

        return;

    }

    delete (MessageFormat*) format;

}

U_CAPI UMessageFormat U_EXPORT2

umsg_clone(const UMessageFormat *fmt,

           UErrorCode *status)

{

    //check arguments

    if(status==NULL || U_FAILURE(*status)){

        return NULL;

    }

    if(fmt==NULL){

        *status = U_ILLEGAL_ARGUMENT_ERROR;

        return NULL;

    }

    UMessageFormat retVal = (UMessageFormat)((MessageFormat*)fmt)->clone();

    if(retVal == 0) {

        *status = U_MEMORY_ALLOCATION_ERROR;

        return 0;

    }

    return retVal;    

}

U_CAPI void  U_EXPORT2

umsg_setLocale(UMessageFormat *fmt, const char* locale)

{

    //check arguments

    if(fmt==NULL){

        return;

    }

    ((MessageFormat*)fmt)->setLocale(Locale(locale));   

}

U_CAPI const char*  U_EXPORT2

umsg_getLocale(const UMessageFormat *fmt)

{

    //check arguments

    if(fmt==NULL){

        return "";

    }

    return ((const MessageFormat*)fmt)->getLocale().getName();

}

U_CAPI void  U_EXPORT2

umsg_applyPattern(UMessageFormat *fmt,

                           const UChar* pattern,

                           int32_t patternLength,

                           UParseError* parseError,

                           UErrorCode* status)

{

    //check arguments

    UParseError tErr;

    if(status ==NULL||U_FAILURE(*status)){

        return ;

    }

    if(fmt==NULL || (pattern==NULL && patternLength!=0) || patternLength<-1) {

        *status=U_ILLEGAL_ARGUMENT_ERROR;

        return ;

    }

    if(parseError==NULL){

      parseError = &tErr;

    }

    // UnicodeString(pattern, -1) calls u_strlen().

    ((MessageFormat*)fmt)->applyPattern(UnicodeString(pattern,patternLength),*parseError,*status);  

}

U_CAPI int32_t  U_EXPORT2

umsg_toPattern(const UMessageFormat *fmt,

               UChar* result, 

               int32_t resultLength,

               UErrorCode* status)

{

    //check arguments

    if(status ==NULL||U_FAILURE(*status)){

        return -1;

    }

    if(fmt==NULL||resultLength<0 || (resultLength>0 && result==0)){

        *status=U_ILLEGAL_ARGUMENT_ERROR;

        return -1;

    }

    UnicodeString res;

    if(!(result==NULL && resultLength==0)) {

        // NULL destination for pure preflighting: empty dummy string

        // otherwise, alias the destination buffer

        res.setTo(result, 0, resultLength);

    }

    ((const MessageFormat*)fmt)->toPattern(res);

    return res.extract(result, resultLength, *status);

}

U_CAPI int32_t

umsg_format(    const UMessageFormat *fmt,

                UChar          *result,

                int32_t        resultLength,

                UErrorCode     *status,

                ...)

{

    va_list    ap;

    int32_t actLen;  

    //argument checking deferred to last method call umsg_vformat which

    //saves time when arguments are valid and we don't care when arguments are not

    //since we return an error anyway

    // start vararg processing

    va_start(ap, status);

    actLen = umsg_vformat(fmt,result,resultLength,ap,status);

    // end vararg processing

    va_end(ap);

    return actLen;

}

U_CAPI int32_t U_EXPORT2

umsg_vformat(   const UMessageFormat *fmt,

                UChar          *result,

                int32_t        resultLength,

                va_list        ap,

                UErrorCode     *status)

{

    //check arguments

    if(status==0 || U_FAILURE(*status))

    {

        return -1;

    }

    if(fmt==NULL||resultLength<0 || (resultLength>0 && result==0)) {

        *status=U_ILLEGAL_ARGUMENT_ERROR;

        return -1;

    }

    int32_t count =0;

    const Formattable::Type* argTypes =

        MessageFormatAdapter::getArgTypeList(*(const MessageFormat*)fmt, count);

    // Allocate at least one element.  Allocating an array of length

    // zero causes problems on some platforms (e.g. Win32).

    Formattable* args = new Formattable[count ? count : 1];

    // iterate through the vararg list, and get the arguments out

    for(int32_t i = 0; i < count; ++i) {

        UChar *stringVal;

        double tDouble=0;

        int32_t tInt =0;

        int64_t tInt64 = 0;

        UDate tempDate = 0;

        switch(argTypes[i]) {

        case Formattable::kDate:

            tempDate = va_arg(ap, UDate);

            args[i].setDate(tempDate);

            break;

        case Formattable::kDouble:

            tDouble =va_arg(ap, double);

            args[i].setDouble(tDouble);

            break;

        case Formattable::kLong:

            tInt = va_arg(ap, int32_t);

            args[i].setLong(tInt);

            break;

        case Formattable::kInt64:

            tInt64 = va_arg(ap, int64_t);

            args[i].setInt64(tInt64);

            break;

        case Formattable::kString:

            // For some reason, a temporary is needed

            stringVal = va_arg(ap, UChar*);

            if(stringVal){

                args[i].setString(UnicodeString(stringVal));

            }else{

                *status=U_ILLEGAL_ARGUMENT_ERROR;

            }

            break;

        case Formattable::kArray:

            // throw away this argument

            // this is highly platform-dependent, and probably won't work

            // so, if you try to skip arguments in the list (and not use them)

            // you'll probably crash

            va_arg(ap, int);

            break;

        case Formattable::kObject:

            // Unused argument number. Read and ignore a pointer argument.

            va_arg(ap, void*);

            break;

        default:

            // Unknown/unsupported argument type.

            UPRV_UNREACHABLE;

        }

    }

    UnicodeString resultStr;

    FieldPosition fieldPosition(FieldPosition::DONT_CARE);

    /* format the message */

    ((const MessageFormat*)fmt)->format(args,count,resultStr,fieldPosition,*status);

    delete[] args;

    if(U_FAILURE(*status)){

        return -1;

    }

    return resultStr.extract(result, resultLength, *status);

}

U_CAPI void

umsg_parse( const UMessageFormat *fmt,

            const UChar    *source,

            int32_t        sourceLength,

            int32_t        *count,

            UErrorCode     *status,

            ...)

{

    va_list    ap;

    //argument checking deferred to last method call umsg_vparse which

    //saves time when arguments are valid and we don't care when arguments are not

    //since we return an error anyway

    // start vararg processing

    va_start(ap, status);

    umsg_vparse(fmt,source,sourceLength,count,ap,status);

    // end vararg processing

    va_end(ap);

}

U_CAPI void U_EXPORT2

umsg_vparse(const UMessageFormat *fmt,

            const UChar    *source,

            int32_t        sourceLength,

            int32_t        *count,

            va_list        ap,

            UErrorCode     *status)

{

    //check arguments

    if(status==NULL||U_FAILURE(*status))

    {

        return;

    }

    if(fmt==NULL||source==NULL || sourceLength<-1 || count==NULL){

        *status=U_ILLEGAL_ARGUMENT_ERROR;

        return;

    }

    if(sourceLength==-1){

        sourceLength=u_strlen(source);

    }

    UnicodeString srcString(source,sourceLength);

    Formattable *args = ((const MessageFormat*)fmt)->parse(srcString,*count,*status);

    UDate *aDate;

    double *aDouble;

    UChar *aString;

    int32_t* aInt;

    int64_t* aInt64;

    UnicodeString temp;

    int len =0;

    // assign formattables to varargs

    for(int32_t i = 0; i < *count; i++) {

        switch(args[i].getType()) {

        case Formattable::kDate:

            aDate = va_arg(ap, UDate*);

            if(aDate){

                *aDate = args[i].getDate();

            }else{

                *status=U_ILLEGAL_ARGUMENT_ERROR;

            }

            break;

        case Formattable::kDouble:

            aDouble = va_arg(ap, double*);

            if(aDouble){

                *aDouble = args[i].getDouble();

            }else{

                *status=U_ILLEGAL_ARGUMENT_ERROR;

            }

            break;

        case Formattable::kLong:

            aInt = va_arg(ap, int32_t*);

            if(aInt){

                *aInt = (int32_t) args[i].getLong();

            }else{

                *status=U_ILLEGAL_ARGUMENT_ERROR;

            }

            break;

        case Formattable::kInt64:

            aInt64 = va_arg(ap, int64_t*);

            if(aInt64){

                *aInt64 = args[i].getInt64();

            }else{

                *status=U_ILLEGAL_ARGUMENT_ERROR;

            }

            break;

        case Formattable::kString:

            aString = va_arg(ap, UChar*);

            if(aString){

                args[i].getString(temp);

                len = temp.length();

                temp.extract(0,len,aString);

                aString[len]=0;

            }else{

                *status= U_ILLEGAL_ARGUMENT_ERROR;

            }

            break;

        case Formattable::kObject:

            // This will never happen because MessageFormat doesn't

            // support kObject.  When MessageFormat is changed to

            // understand MeasureFormats, modify this code to do the

            // right thing. [alan]

            UPRV_UNREACHABLE;

        // better not happen!

        case Formattable::kArray:

            UPRV_UNREACHABLE;

        }

    }

    // clean up

    delete [] args;

}

#define SINGLE_QUOTE      ((UChar)0x0027)

#define CURLY_BRACE_LEFT  ((UChar)0x007B)

#define CURLY_BRACE_RIGHT ((UChar)0x007D)

#define STATE_INITIAL 0

#define STATE_SINGLE_QUOTE 1

#define STATE_IN_QUOTE 2

#define STATE_MSG_ELEMENT 3

#define MAppend(c) if (len < destCapacity) dest[len++] = c; else len++

int32_t umsg_autoQuoteApostrophe(const UChar* pattern, 

                 int32_t patternLength,

                 UChar* dest,

                 int32_t destCapacity,

                 UErrorCode* ec)

{

    int32_t state = STATE_INITIAL;

    int32_t braceCount = 0;

    int32_t len = 0;

    if (ec == NULL || U_FAILURE(*ec)) {

        return -1;

    }

    if (pattern == NULL || patternLength < -1 || (dest == NULL && destCapacity > 0)) {

        *ec = U_ILLEGAL_ARGUMENT_ERROR;

        return -1;

    }

    U_ASSERT(destCapacity >= 0);

    if (patternLength == -1) {

        patternLength = u_strlen(pattern);

    }

    for (int i = 0; i < patternLength; ++i) {

        UChar c = pattern[i];

        switch (state) {

        case STATE_INITIAL:

            switch (c) {

            case SINGLE_QUOTE:

                state = STATE_SINGLE_QUOTE;

                break;

            case CURLY_BRACE_LEFT:

                state = STATE_MSG_ELEMENT;

                ++braceCount;

                break;

            }

            break;

        case STATE_SINGLE_QUOTE:

            switch (c) {

            case SINGLE_QUOTE:

                state = STATE_INITIAL;

                break;

            case CURLY_BRACE_LEFT:

            case CURLY_BRACE_RIGHT:

                state = STATE_IN_QUOTE;

                break;

            default:

                MAppend(SINGLE_QUOTE);

                state = STATE_INITIAL;

                break;

            }

        break;

        case STATE_IN_QUOTE:

            switch (c) {

            case SINGLE_QUOTE:

                state = STATE_INITIAL;

                break;

            }

            break;

        case STATE_MSG_ELEMENT:

            switch (c) {

            case CURLY_BRACE_LEFT:

                ++braceCount;

                break;

            case CURLY_BRACE_RIGHT:

                if (--braceCount == 0) {

                    state = STATE_INITIAL;

                }

                break;

            }

            break;

        default: // Never happens.

            break;

        }

        U_ASSERT(len >= 0);

        MAppend(c);

    }

    // End of scan

    if (state == STATE_SINGLE_QUOTE || state == STATE_IN_QUOTE) {

        MAppend(SINGLE_QUOTE);

    }

    return u_terminateUChars(dest, destCapacity, len, ec);

}

#endif /* #if !UCONFIG_NO_FORMATTING */