content: /*
   * CSVeed (https://github.com/42BV/CSVeed)
   *
   * Copyright 2013-2023 CSVeed.
   *
   * All rights reserved. This program and the accompanying materials
   * are made available under the terms of The Apache Software License,
   * Version 2.0 which accompanies this distribution, and is available at
   * https://www.apache.org/licenses/LICENSE-2.0.txt
   */
  package org.csveed.bean.conversion;
  
  import static org.csveed.bean.conversion.ConversionUtil.trimAllWhitespace;
  
  import java.math.BigDecimal;
  import java.math.BigInteger;
  import java.text.DecimalFormat;
  import java.text.NumberFormat;
  import java.text.ParseException;
  
  /**
   * The Class NumberUtils.
   */
  public abstract class NumberUtils {
  
      /**
       * Instantiates a new number utils.
       */
      private NumberUtils() {
          // Do not allow instantiation of static utils class
      }
  
      /**
       * Convert number to target class.
       *
       * @param <T>
       *            the generic type
       * @param number
       *            the number
       * @param targetClass
       *            the target class
       *
       * @return the t
       *
       * @throws IllegalArgumentException
       *             the illegal argument exception
       */
      @SuppressWarnings("unchecked")
      public static <T extends Number> T convertNumberToTargetClass(Number number, Class<T> targetClass)
              throws IllegalArgumentException {
  
          if (targetClass.isInstance(number)) {
              return (T) number;
          }
          if (targetClass.equals(Byte.class)) {
              long value = number.longValue();
              if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
                  raiseOverflowException(number, targetClass);
              }
              return (T) Byte.valueOf(number.byteValue());
          }
          if (targetClass.equals(Short.class)) {
              long value = number.longValue();
              if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
                  raiseOverflowException(number, targetClass);
              }
              return (T) Short.valueOf(number.shortValue());
          }
          if (targetClass.equals(Integer.class)) {
              long value = number.longValue();
              if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
                  raiseOverflowException(number, targetClass);
              }
              return (T) Integer.valueOf(number.intValue());
          }
          if (targetClass.equals(Long.class)) {
              return (T) Long.valueOf(number.longValue());
          }
          if (targetClass.equals(BigInteger.class)) {
              if (number instanceof BigDecimal) {
                  // do not lose precision - use BigDecimal's own conversion
                  return (T) ((BigDecimal) number).toBigInteger();
              }
              // original value is not a Big* number - use standard long conversion
              return (T) BigInteger.valueOf(number.longValue());
          }
          if (targetClass.equals(Float.class)) {
              return (T) Float.valueOf(number.floatValue());
          }
          if (targetClass.equals(Double.class)) {
              return (T) Double.valueOf(number.doubleValue());
          }
          if (targetClass.equals(BigDecimal.class)) {
              // always use BigDecimal(String) here to avoid unpredictability of BigDecimal(double)
              // (see BigDecimal javadoc for details)
              return (T) new BigDecimal(number.toString());
          }
          throw new IllegalArgumentException("Could not convert number [" + number + "] of type ["
                  + number.getClass().getName() + "] to unknown target class [" + targetClass.getName() + "]");
      }
  
      /**
       * Raise overflow exception.
       *
       * @param number
       *            the number
       * @param targetClass
       *            the target class
       */
      private static void raiseOverflowException(Number number, Class targetClass) {
          throw new IllegalArgumentException("Could not convert number [" + number + "] of type ["
                  + number.getClass().getName() + "] to target class [" + targetClass.getName() + "]: overflow");
      }
  
      /**
       * Parses the number.
       *
       * @param <T>
       *            the generic type
       * @param text
       *            the text
       * @param targetClass
       *            the target class
       *
       * @return the t
       */
      @SuppressWarnings("unchecked")
      public static <T extends Number> T parseNumber(String text, Class<T> targetClass) {
          String trimmed = trimAllWhitespace(text);
  
          if (targetClass.equals(Byte.class)) {
              return (T) (isHexNumber(trimmed) ? Byte.decode(trimmed) : Byte.valueOf(trimmed));
          }
          if (targetClass.equals(Short.class)) {
              return (T) (isHexNumber(trimmed) ? Short.decode(trimmed) : Short.valueOf(trimmed));
          }
          if (targetClass.equals(Integer.class)) {
              return (T) (isHexNumber(trimmed) ? Integer.decode(trimmed) : Integer.valueOf(trimmed));
          }
          if (targetClass.equals(Long.class)) {
              return (T) (isHexNumber(trimmed) ? Long.decode(trimmed) : Long.valueOf(trimmed));
          }
          if (targetClass.equals(BigInteger.class)) {
              return (T) (isHexNumber(trimmed) ? decodeBigInteger(trimmed) : new BigInteger(trimmed));
          }
          if (targetClass.equals(Float.class)) {
              return (T) Float.valueOf(trimmed);
          }
          if (targetClass.equals(Double.class)) {
              return (T) Double.valueOf(trimmed);
          }
          if (targetClass.equals(BigDecimal.class) || targetClass.equals(Number.class)) {
              return (T) new BigDecimal(trimmed);
          }
          throw new IllegalArgumentException(
                  "Cannot convert String [" + text + "] to target class [" + targetClass.getName() + "]");
      }
  
      /**
       * Parses the number.
       *
       * @param <T>
       *            the generic type
       * @param text
       *            the text
       * @param targetClass
       *            the target class
       * @param numberFormat
       *            the number format
       *
       * @return the t
       */
      public static <T extends Number> T parseNumber(String text, Class<T> targetClass, NumberFormat numberFormat) {
          if (numberFormat != null) {
              DecimalFormat decimalFormat = null;
              boolean resetBigDecimal = false;
              if (numberFormat instanceof DecimalFormat) {
                  decimalFormat = (DecimalFormat) numberFormat;
                  if (BigDecimal.class.equals(targetClass) && !decimalFormat.isParseBigDecimal()) {
                      decimalFormat.setParseBigDecimal(true);
                      resetBigDecimal = true;
                  }
              }
              try {
                  Number number = numberFormat.parse(trimAllWhitespace(text));
                  return convertNumberToTargetClass(number, targetClass);
              } catch (ParseException ex) {
                  throw new IllegalArgumentException("Could not parse number: " + ex.getMessage());
              } finally {
                  if (resetBigDecimal && decimalFormat != null) {
                      decimalFormat.setParseBigDecimal(false);
                  }
              }
          }
          return parseNumber(text, targetClass);
      }
  
      /**
       * Checks if is hex number.
       *
       * @param value
       *            the value
       *
       * @return true, if is hex number
       */
      private static boolean isHexNumber(String value) {
          int index = value.startsWith("-") ? 1 : 0;
          return value.startsWith("0x", index) || value.startsWith("0X", index) || value.startsWith("#", index);
      }
  
      /**
       * Decode big integer.
       *
       * @param value
       *            the value
       *
       * @return the big integer
       */
      private static BigInteger decodeBigInteger(String value) {
          int radix = 10;
          int index = 0;
          boolean negative = false;
  
          // Handle minus sign, if present.
          if (value.startsWith("-")) {
              negative = true;
              index++;
          }
  
          // Handle radix specifier, if present.
          if (value.startsWith("0x", index) || value.startsWith("0X", index)) {
              index += 2;
              radix = 16;
          } else if (value.startsWith("#", index)) {
              index++;
              radix = 16;
          } else if (value.startsWith("0", index) && value.length() > 1 + index) {
              index++;
              radix = 8;
          }
  
          BigInteger result = new BigInteger(value.substring(index), radix);
          return negative ? result.negate() : result;
      }
  
  }
  