/*
 * Copyright (c) 2019, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer in the documentation and/or other materials provided
 *      with the distribution.
 *    * Neither the name of The Linux Foundation nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "AEEstd.h"
#include "AEEBufBound.h"
#include "AEEsmath.h"
#include "AEEStdErr.h"
#include "std_dtoa.h"
//#include "math.h"

//==============================================================================
//   Macro definitions
//==============================================================================

#define  ISDIGIT(c)              ( (c) >= '0' && (c) <= '9')
#define  TOLOWER(c)              ( (c) | 32 )   // works only for letters
#define  FAILED(b)               ( (b) != AEE_SUCCESS ? TRUE : FALSE )
#define  CLEANUP_ON_ERROR(b,l)   if( FAILED( b ) ) { goto l; }
#define  ROUND(d, p)             fp_round( d, p )
#define  FP_POW_10(n)            fp_pow_10(n)

//==============================================================================
//   Type definitions
//==============================================================================


// Formatting flags

#define FF_PLUS     1    // '+'
#define FF_MINUS    2    // '-'
#define FF_POUND    4    // '#'
#define FF_BLANK    8    // ' '
#define FF_ZERO    16    // '0'

typedef struct {

   // Parsed values (from "%..." expression)

   int      flags;          // FF_PLUS, FF_MINUS, etc.
   char     cType;          // d, s, c, x, X, etc.
   int32    nWidth;         // number preceding '.' : controls padding
   int32    nPrecision;     // number following '.'  (-1 if not given)

   // Computed values

   const char *  pszStr;         // string holding prefix + value
   int           nPrefix;        // # of numeric prefix bytes in pszStr[]
   int           nLen;           // length of string (after prefix)
   int           nNumWidth;      // minimum numeric value size (pad with '0')

} FieldFormat;

typedef int (*pfnFormatFloat)(FieldFormat* me, double dNumber, char* pcBuffer);

//==============================================================================
//   Function definitions
//==============================================================================

// Read an unsigned decimal integer
//
static int ScanDecimal(const char **ppsz)
{
   int n = 0;
   const char *psz;

   for (psz = *ppsz; ISDIGIT(*psz); ++psz) {
      n = n*10 + (int) (*psz - '0');
   }
   *ppsz = psz;
   return n;
}


#define FORMATNUMBER_SIZE   24   // octal: 22 + '0' + null ;  decimal: 20 + sign + null


// Convert number to string, setting computed fields in FieldFormat.
//
//  pcBuf[] must have room for at least FORMATNUMBER_SIZE characters
//  return value: length of string.
//
static __inline void
FormatNumber(FieldFormat *me, char pcBuf[FORMATNUMBER_SIZE], uint64 uNum64)
{
   char cType = me->cType;
   const char *cpszDigits;
   char *pc = pcBuf;
   int nBase;
   char *pcRev;

   if (cType == 'p') {
      cType = 'X';
      me->nPrecision = 8;
   }

   if (me->nPrecision >= 0) {
      me->nNumWidth = me->nPrecision;
      // Odd thing: '0' flag is ignored for numbers when precision is
      // specified.
      me->flags &= ~FF_ZERO;
   } else {
      me->nNumWidth = 1;
   }

   // Output prefix

   if (( 'd' == cType || 'i' == cType)) {
      if ((int64)uNum64 < 0) {
         *pc++ = '-';
         uNum64 = (uint64)-(int64)uNum64;
      } else if (me->flags & FF_PLUS) {
         *pc++ = '+';
      } else if (me->flags & FF_BLANK) {
         *pc++ = ' ';
      }
   }

   if ((me->flags & FF_POUND) && 0 != uNum64) {
      if ('x' == TOLOWER(cType)) {
         *pc++ = '0';
         *pc++ = cType;
      } else if ('o' == cType) {
         *pc++ = '0';
         // Odd thing about libc printf: "0" prefix counts as part of minimum
         // width, but "0x" prefix does not.
         --me->nNumWidth;
      }
   }
   me->nPrefix = pc - pcBuf;

   // Output unsigned numeric value

   nBase = ('o' == cType          ? 8 :
            'x' == TOLOWER(cType) ? 16 :
            10);
   cpszDigits = ((cType == 'X') ? "0123456789ABCDEF"
                                : "0123456789abcdef");

   pcRev = pc;

   while (uNum64) {
      *pc++ = cpszDigits[uNum64 % (unsigned)nBase];
      uNum64 /= (unsigned)nBase;
   }

   *pc = '\0';

   me->pszStr = pcBuf;
   me->nLen = pc - pcRev;

   // Reverse string

   --pc;
   for (; pcRev < pc; ++pcRev, --pc) {
      char c = *pc;
      *pc = *pcRev;
      *pcRev = c;
   }
}

//
// This function converts the input floating point number dNumber to an
// ASCII string using either %f or %F formatting. This functions assumes
// that dNumer is a valid floating point number (i.e., dNumber is NOT
// +/-INF or NaN). The size of the output buffer pcBuffer should be at
// least STD_DTOA_FORMAT_FLOAT_SIZE.
//
static int ConvertFloat(FieldFormat* me, double dNumber, char* pcBuffer,
                        int nBufSize)
{
   int nError = AEE_SUCCESS;
   int32 nPrecision = 0;
   int nIndex = 0;
   BufBound OutBuf;
   char szIntegerPart[STD_DTOA_FORMAT_INTEGER_SIZE] = {0};
   char szFractionPart[STD_DTOA_FORMAT_FRACTION_SIZE] = {0};
   int nExponent = 0;
   char cType = TOLOWER(me->cType);

   // Set the precision for conversion
   nPrecision = me->nPrecision;
   if (nPrecision < 0) {
      // No precision was specified, set it to the default value if the
      // format specifier is not %a
      if (cType != 'a') {
         nPrecision = STD_DTOA_DEFAULT_FLOAT_PRECISION;
      }
   }
   else if ((0 == nPrecision) && ('g' == cType)) {
      nPrecision = 1;
   }

   if (cType != 'a') {
      // For %g, check whether to use %e of %f formatting style.
      // Also, set the precision value accordingly since in this case the user
      // specified value is really the number of significant digits.
      // These next few steps should be skipped if the input number is 0.
      if (dNumber != 0.0) {
         nExponent = fp_log_10(dNumber);
         if ('g' == cType) {
            if ((nExponent < -4) || (nExponent >= nPrecision)) {
               cType = 'e';
               nPrecision = nPrecision - 1;
            }
            else {
               cType = 'f';
               nPrecision = nPrecision - nExponent - 1;
            }
         }

         // For %e, convert the number to the form d.ddd
         if ('e' == cType) {
            dNumber = dNumber / FP_POW_10(nExponent);
         }

         // Now, round the number to the specified precision
         dNumber = ROUND(dNumber, nPrecision);

         // For %e, the rounding operation may have resulted in a number dd.ddd
         // Reconvert it to the form d.ddd
         if (('e' == cType) && ((dNumber >= 10.0) || (dNumber <= -10.0))) {
            dNumber = dNumber / 10.0;
            nExponent++;
         }
      }

      // Convert the decmial number to string
      nError = std_dtoa_decimal(dNumber, nPrecision, szIntegerPart, szFractionPart);
      CLEANUP_ON_ERROR(nError, bail);
   }
   else
   {
      // Conver the hex floating point number to string
      nError = std_dtoa_hex(dNumber, nPrecision, me->cType, szIntegerPart,
                            szFractionPart, &nExponent);
      CLEANUP_ON_ERROR(nError, bail);
   }


   //
   // Write the output as per the specified format.
   // First: Check for any prefixes that need to be added to the output.
   // The only possible prefixes are '-', '+' or ' '. The following rules
   // are applicable:
   // 1. One and only one prefix will be applicable at any time.
   // 2. If the number is negative, then '+' and ' ' are not applicable.
   // 3. For positive numbers, the prefix '+' takes precedence over ' '.
   //
   // In addition, we were dealing with a hex floating point number (%a),
   // then we need to write of the 0x prefix.
   //
   BufBound_Init(&OutBuf, pcBuffer, nBufSize);
   if (dNumber < 0.0) {
      // The '-' sign would have already been added to the szIntegerPart by
      // the conversion function.
      me->nPrefix = 1;
   }
   if (dNumber >= 0.0){
      if (me->flags & FF_PLUS) {
         BufBound_Putc(&OutBuf, '+');
         me->nPrefix = 1;
      }
      else if(me->flags & FF_BLANK) {
         BufBound_Putc(&OutBuf, ' ');
         me->nPrefix = 1;
      }
   }

   // For %a, write out the 0x prefix
   if ('a' == cType) {
      BufBound_Putc(&OutBuf, '0');
      BufBound_Putc(&OutBuf, ('a' == me->cType) ? 'x' : 'X');
      me->nPrefix += 2;
   }

   // Second: Write the integer part
   BufBound_Puts(&OutBuf, szIntegerPart);

   // Third: Write the decimal point followed by the fraction part.
   // For %g, we need to truncate the trailing zeros in the fraction.
   // Skip this if the '#' flag is specified
   if (!(me->flags & FF_POUND) && ('g' == TOLOWER(me->cType))) {
      for (nIndex = std_strlen(szFractionPart) - 1;
           (nIndex >= 0) && (szFractionPart[nIndex] == '0'); nIndex--) {
         szFractionPart[nIndex] = '\0';
      }
   }

   // The decimal point is specified only if there are some decimal digits.
   // However, if the '#' format specifier is present then the decimal point
   // will be present.
   if ((me->flags & FF_POUND) || (*szFractionPart != 0)) {
      BufBound_Putc(&OutBuf, '.');

      // Write the fraction part
      BufBound_Puts(&OutBuf, szFractionPart);
   }

   // For %e and %a, write out the exponent
   if (('e' == cType) || ('a' == cType)) {
      char* pcExpStart = NULL;
      char* pcExpEnd = NULL;
      char cTemp = 0;

      if ('a' == me->cType) {
         BufBound_Putc(&OutBuf, 'p');
      }
      else if ('A' == me->cType) {
         BufBound_Putc(&OutBuf, 'P');
      }
      else if (('e' == me->cType) || ('g' == me->cType)) {
         BufBound_Putc(&OutBuf, 'e');
      }
      else {
         BufBound_Putc(&OutBuf, 'E');
      }

      // Write the exponent sign
      if (nExponent < 0) {
         BufBound_Putc(&OutBuf, '-');
         nExponent = -nExponent;
      }
      else {
         BufBound_Putc(&OutBuf, '+');
      }

      // Write out the exponent.
      // For %e, the exponent should at least be two digits.
      // The exponent to be written will be at most 4 digits as any
      // overflow would have been take care of by now.
      if (BufBound_Left(&OutBuf) >= 4) {
         if ('e' == cType) {
            if (nExponent < 10) {
               BufBound_Putc(&OutBuf, '0');
            }
         }

         pcExpStart = OutBuf.pcWrite;
         do {
            BufBound_Putc(&OutBuf, '0' + (nExponent % 10));
            nExponent /= 10;
         } while (nExponent);
         pcExpEnd = OutBuf.pcWrite - 1;

         // Reverse the exponent
         for (; pcExpStart < pcExpEnd; pcExpStart++, pcExpEnd--) {
            cTemp = *pcExpStart;
            *pcExpStart = *pcExpEnd;
            *pcExpEnd = cTemp;
         }
      }
   }

   // Null-terminate the string
   BufBound_ForceNullTerm(&OutBuf);

   // Set the output parameters
   // We do not care if there was enough space in the output buffer or not.
   // The output would be truncated to a maximum length of
   // STD_DTOA_FORMAT_FLOAT_SIZE.
   me->pszStr = OutBuf.pcBuf;
   me->nLen = BufBound_ReallyWrote(&OutBuf) - me->nPrefix - 1;

bail:

   return nError;
}

//
// This is a wrapper function that converts an input floating point number
// to a string based on a given format specifier %e, %f or %g. It first checks
// if the specified number is a valid floating point number before calling
// the function that does the conversion.
//
// The size of the output buffer pcBuffer should be at least STD_DTOA_FORMAT_FLOAT_SIZE.
//
static int FormatFloat(FieldFormat* me, double dNumber,
                       char pcBuffer[STD_DTOA_FORMAT_FLOAT_SIZE])
{
   int nError = AEE_SUCCESS;
   FloatingPointType NumberType = FP_TYPE_UNKOWN;

   // Check for error conditions
   if (NULL == pcBuffer) {
      nError = AEE_EBADPARM;
      goto bail;
   }

   // Initialize the output params first
   me->nLen = 0;
   me->nPrefix = 0;

   // Check for special cases such as NaN and Infinity
   nError = fp_check_special_cases(dNumber, &NumberType);
   CLEANUP_ON_ERROR(nError, bail);

   switch(NumberType) {
	  case FP_TYPE_NEGATIVE_INF:

		 if (('E' == me->cType) || ('F' == me->cType) || ('G' == me->cType)) {
			me->nLen = std_strlcpy(pcBuffer, STD_DTOA_NEGATIVE_INF_UPPER_CASE,
								   STD_DTOA_FORMAT_FLOAT_SIZE);
		 }
		 else {
			me->nLen = std_strlcpy(pcBuffer, STD_DTOA_NEGATIVE_INF_LOWER_CASE,
								   STD_DTOA_FORMAT_FLOAT_SIZE);
		 }

		 // Don't pad with 0's
		 me->flags &= ~FF_ZERO;

		 break;

	  case FP_TYPE_POSITIVE_INF:

		 if (('E' == me->cType) || ('F' == me->cType) || ('G' == me->cType)) {
			me->nLen = std_strlcpy(pcBuffer, STD_DTOA_POSITIVE_INF_UPPER_CASE,
								   STD_DTOA_FORMAT_FLOAT_SIZE);
		 }
		 else {
			me->nLen = std_strlcpy(pcBuffer, STD_DTOA_POSITIVE_INF_LOWER_CASE,
								   STD_DTOA_FORMAT_FLOAT_SIZE);
		 }

		 // Don't pad with 0's
		 me->flags &= ~FF_ZERO;

		 break;

	  case FP_TYPE_NAN:

		 if (('E' == me->cType) || ('F' == me->cType) || ('G' == me->cType)) {
			me->nLen = std_strlcpy(pcBuffer, STD_DTOA_NAN_UPPER_CASE,
								   STD_DTOA_FORMAT_FLOAT_SIZE);
		 }
		 else
		 {
			me->nLen = std_strlcpy(pcBuffer, STD_DTOA_NAN_LOWER_CASE,
								   STD_DTOA_FORMAT_FLOAT_SIZE);
		 }

		 // Don't pad with 0's
		 me->flags &= ~FF_ZERO;

		 break;

	  case FP_TYPE_GENERAL:

		 nError = ConvertFloat(me, dNumber, pcBuffer,
                               STD_DTOA_FORMAT_FLOAT_SIZE);
		 CLEANUP_ON_ERROR(nError, bail);

		 break;

	  default:

		 // This should only happen if this function has been modified
		 // to support other special cases and this block has not been
		 // updated.
		 nError = AEE_EFAILED;
		 goto bail;
   }

   // Set the output parameters
   me->pszStr = pcBuffer;


bail:

   return nError;
}

static int std_strlprintf_inner(char *pszDest, int nDestSize,
                                const char *cpszFmt, AEEVaList args,
                                pfnFormatFloat pfnFormatFloatFunc)
{
   BufBound bb;
   const char *pcIn = cpszFmt;

   BufBound_Init(&bb, pszDest, nDestSize);

   for (;;) {
      FieldFormat ff;
      const char *pcEsc;
      char achBuf[FORMATNUMBER_SIZE];
      char achBuf2[STD_DTOA_FORMAT_FLOAT_SIZE];
      char cType;
      boolean bLong = 0;

      pcEsc = std_strchrend(pcIn, '%');
      BufBound_Write(&bb, pcIn, pcEsc-pcIn);

      if (0 == *pcEsc) {
         break;
      }
      pcIn = pcEsc+1;

      //----------------------------------------------------
      // Consume "%..." specifiers:
      //
      //   %[FLAGS] [WIDTH] [.PRECISION] [{h | l | I64 | L}]
      //----------------------------------------------------

      std_memset(&ff, 0, sizeof(FieldFormat));
      ff.nPrecision = -1;

      // Consume all flags
      for (;;) {
         int f;

         f = (('+' == *pcIn) ? FF_PLUS  :
              ('-' == *pcIn) ? FF_MINUS :
              ('#' == *pcIn) ? FF_POUND :
              (' ' == *pcIn) ? FF_BLANK :
              ('0' == *pcIn) ? FF_ZERO  : 0);

         if (0 == f) {
            break;
         }

         ff.flags |= f;
         ++pcIn;
      }

      // Consume width
      if ('*' == *pcIn) {
         AEEVA_ARG(args, ff.nWidth, int32);
         pcIn++;
      } else {
         ff.nWidth = ScanDecimal(&pcIn);
      }
      if ((ff.flags & FF_MINUS) && ff.nWidth > 0) {
         ff.nWidth = -ff.nWidth;
      }

      // Consume precision
      if ('.' == *pcIn) {
         pcIn++;
         if ('*' == *pcIn) { // Can be *... (given in int * param)
            AEEVA_ARG(args, ff.nPrecision, int32);
            pcIn++;
         } else {
            ff.nPrecision = ScanDecimal(&pcIn);
         }
      }

      // Consume size designator
      {
         static const struct {
            char    szPre[3];
            boolean b64;
         } a[] = {
            { "l",  0, },
            { "ll", 1, },
            { "L",  1, },
            { "j",  1, },
            { "h",  0, },
            { "hh", 0, },
            { "z",  0 }
         };

         int n = STD_ARRAY_SIZE(a);

         while (--n >= 0) {
            const char *psz = std_strbegins(pcIn, a[n].szPre);
            if ((const char*)0 != psz) {
               pcIn = psz;
               bLong = a[n].b64;
               break;
            }
         }
      }

      //----------------------------------------------------
      //
      // Format output values
      //
      //----------------------------------------------------

      ff.cType = cType = *pcIn++;

      if ('s' == cType) {

         // String
         char *psz;

         AEEVA_ARG(args, psz, char*);
         ff.pszStr = psz;
         ff.nLen = std_strlen(psz);
         if (ff.nPrecision >= 0 && ff.nPrecision < ff.nLen) {
            ff.nLen = ff.nPrecision;
         }

      } else if ('c' == cType) {

         // char
         AEEVA_ARG(args, achBuf[0], int);
         achBuf[1] = '\0';
         ff.pszStr = achBuf;
         ff.nLen = 1;

      } else if ('u' == cType ||
                 'o' == cType ||
                 'd' == cType ||
                 'i' == cType ||
                 'p' == cType ||
                 'x' == TOLOWER(cType) ) {

         // int
         uint64 uArg64;

         if (bLong) {
            AEEVA_ARG(args, uArg64, int64);  // See how much room needed
         } else {
            uint32 uArg32;
            AEEVA_ARG(args, uArg32, int32);  // See how much room needed
            uArg64 = uArg32;
            if ('d' == cType || 'i' == cType) {
               uArg64 = (uint64)(int64)(int32)uArg32;
            }
         }

         FormatNumber(&ff, achBuf, uArg64);

      } else if (pfnFormatFloatFunc &&
                 ('e' == TOLOWER(cType) ||
                  'f' == TOLOWER(cType) ||
                  'g' == TOLOWER(cType) ||
                  'a' == TOLOWER(cType))) {

         // float
            int nError = AEE_SUCCESS;
            double dNumber;

            AEEVA_ARG(args, dNumber, double);
            nError = pfnFormatFloatFunc(&ff, dNumber, achBuf2);
            if (FAILED(nError)) {
               continue;
            }

      } else if ('\0' == cType) {

         // premature end
         break;

      } else {
         // Unknown type
         BufBound_Putc(&bb, cType);
         continue;
      }

      // FieldFormat computed variables + nWidth controls output

      if (ff.flags & FF_ZERO) {
         ff.nNumWidth = ff.nWidth - ff.nPrefix;
      }

      {
         int nLen1 = ff.nLen;
         int nLen2 = STD_MAX(ff.nNumWidth, nLen1) + ff.nPrefix;

         // Putnc() safely ignores negative sizes
         BufBound_Putnc(&bb, ' ', smath_Sub(ff.nWidth,nLen2));
         BufBound_Write(&bb, ff.pszStr, ff.nPrefix);
         BufBound_Putnc(&bb, '0', smath_Sub(ff.nNumWidth, nLen1));
         BufBound_Write(&bb, ff.pszStr+ff.nPrefix, nLen1);
         BufBound_Putnc(&bb, ' ', smath_Sub(-nLen2, ff.nWidth));
      }
   }

   AEEVA_END(args);

   BufBound_ForceNullTerm(&bb);

   /* Return number of bytes required regardless if buffer bound was reached */

   /* Note that we subtract 1 because the NUL byte which was added in
      BufBound_ForceNullTerm() is counted as a written byte; the semantics
      of both the ...printf() functions and the strl...() functions call for
      the NUL byte to be excluded from the count. */

   return BufBound_Wrote(&bb)-1;
}

int std_vstrlprintf(char *pszDest, int nDestSize,
                    const char *cpszFmt,
                    AEEVaList args)
{
   return std_strlprintf_inner(pszDest, nDestSize, cpszFmt, args, NULL);
}

int std_vsnprintf(char *pszDest, int nDestSize,
                  const char *cpszFmt,
                  AEEVaList args)
/*
   Same as std_vstrlprintf with the additional support of floating point
   conversion specifiers - %e, %f, %g and %a
*/
{
   return std_strlprintf_inner(pszDest, nDestSize, cpszFmt, args, FormatFloat);
}

int std_strlprintf(char *pszDest, int nDestSize, const char *pszFmt, ...)
{
   int nRet;
   AEEVaList args;

   AEEVA_START(args, pszFmt);

   nRet = std_vstrlprintf(pszDest, nDestSize, pszFmt, args);

   AEEVA_END(args);

   return nRet;
}

int std_snprintf(char *pszDest, int nDestSize, const char *pszFmt, ...)
/*
   Same as std_strlprintf with the additional support of floating point
   conversion specifiers - %e, %f, %g and %a
*/
{
   int nRet;
   AEEVaList args;

   AEEVA_START(args, pszFmt);

   nRet = std_vsnprintf(pszDest, nDestSize, pszFmt, args);

   AEEVA_END(args);

   return nRet;
}