package emissary.server.mvc.adapters;
   
   import jakarta.servlet.ServletRequest;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import java.util.ArrayList;
   import java.util.List;
   import javax.annotation.Nullable;
  
  /**
   * Utilities for dealing with request parameters
   */
  @SuppressWarnings("AvoidObjectArrays")
  public class RequestUtil {
      public static final int INT_PARAM_NOT_FOUND = -99;
      public static final float FLOAT_PARAM_NOT_FOUND = -99.99f;
  
      private static final Logger logger = LoggerFactory.getLogger(RequestUtil.class);
  
      private RequestUtil() {}
  
      /**
       * Get attribute or parameter from request. Attribute has priority over parameter when both are present. If no parameter
       * is found, return the default value.
       */
      public static String getParameter(final ServletRequest request, final String param, @Nullable final String defaultVal) {
          Object o = request.getAttribute(param);
          if (o == null) {
              o = sanitizeParameter(request.getParameter(param));
          }
  
          if (o == null) {
              o = defaultVal;
          }
          return (String) o;
      }
  
  
      /**
       * Get attribute or parameter from request. Attribute has priority over parameter when both are present. If no parameter
       * is found, return null.
       */
      public static String getParameter(final ServletRequest request, final String param) {
          return getParameter(request, param, null);
      }
  
      /**
       * Get attribute or parameters from request and return an array of Strings. Attribute has priority over parameter when
       * both are present
       */
      public static String[] getParameterValues(final ServletRequest request, final String param) {
          String[] retArray;
          Object o = request.getAttribute(param);
  
          if (o == null) {
              o = sanitizeParameters(request.getParameterValues(param));
          }
  
          try {
              retArray = (String[]) o;
          } catch (ClassCastException e) {
              retArray = new String[1];
              retArray[0] = (String) o;
          }
  
          if (retArray != null) {
              for (int i = 0; i < retArray.length; i++) {
                  logger.debug("RequestUtil.getParameterValues for {} [{}]: {}", param, i, retArray[i]);
              }
          } else {
              logger.debug("RequestUtil.getParameterValues for {} is null", param);
          }
  
          return retArray;
      }
  
      /**
       * gets an int parameter.
       *
       * @return the parameter's int value, or -99 if the parameter is null.
       */
      public static int getIntParam(final ServletRequest request, final String param) {
          return getIntParam(request, param, INT_PARAM_NOT_FOUND);
      }
  
      /**
       * gets an int parameter.
       *
       * @return the parameter's int value, or the default value if the parameter is null.
       */
      public static int getIntParam(final ServletRequest request, final String param, final int defValue) {
          int retval = defValue;
          String sInt = getParameter(request, param);
          if (sInt != null) {
              sInt = sInt.trim();
              if (sInt.length() > 0) {
                  try {
                      retval = Integer.parseInt(sInt);
                 } catch (NumberFormatException e) {
                     logger.info("RequestUtil.getIntParam. Param {} had unparseable value '{}'.", param, sInt);
 
                 }
             }
         }
 
         logger.debug("RequestUtil.getIntParam for {}: {}.", param, retval);
 
         return retval;
     }
 
     /**
      * Retrieves boolean as a String ("true") and returns boolean.
      * 
      * @return boolean
      */
     public static boolean getBooleanParam(final ServletRequest request, final String param) {
         return getBooleanParam(request, param, "true", false);
     }
 
     /**
      * Retrieves boolean if the string value of the parameter equals the trueString argument. If the parameter is not
      * present, false will be returned
      * 
      * @return boolean
      */
     public static boolean getBooleanParam(final ServletRequest request, final String param, final String trueString) {
         return getBooleanParam(request, param, trueString, false);
     }
 
     /**
      * Retrieves boolean if the string value of the parameter equals the trueString argument.
      * 
      * @return boolean
      */
     public static boolean getBooleanParam(final ServletRequest request, final String param, final String trueString, final boolean defaultVal) {
         final String s = getParameter(request, param);
         if (s != null) {
             return s.equalsIgnoreCase(trueString);
         }
 
         return defaultVal;
     }
 
     /**
      * Retrieves a list of Integers from the request
      * 
      * @return Integer[]
      */
     public static Integer[] getIntegers(final ServletRequest request, final String param) {
         return getIntegers(request, param, INT_PARAM_NOT_FOUND);
     }
 
     /**
      * Retrieves a list of Integers from the request
      * 
      * @return Integer[]
      */
     public static Integer[] getIntegers(final ServletRequest request, final String param, final int defValue) {
         final String[] values = getParameterValues(request, param);
 
         if (values == null) {
             return new Integer[0];
         }
 
         final Integer[] intValues = new Integer[values.length];
 
         for (int i = 0; i < values.length; i++) {
             try {
                 String temp = values[i];
                 if (temp != null) {
                     temp = temp.trim();
                 }
                 intValues[i] = Integer.valueOf(temp);
             } catch (NumberFormatException ne) {
                 logger.info("RequestUtil.getIntegers. Param {} had unparseable value '{}'.", param, values[i]);
 
                 intValues[i] = defValue;
             }
         }
 
         return intValues;
     }
 
     /**
      * gets a string parameter
      *
      * @return the parameter's value, or "" if the parameter is null.
      */
     public static String getParamNoNull(final ServletRequest request, final String param) {
         final String temp = getParameter(request, param);
         if (temp != null) {
             return temp;
         }
         return "";
     }
 
     /**
      * gets a float parameter.
      *
      * @return the parameter's int value, or -99 if the parameter is null.
      */
     public static float getFloatParam(final ServletRequest request, final String param) {
         return getFloatParam(request, param, FLOAT_PARAM_NOT_FOUND);
     }
 
     /**
      * gets a float parameter.
      *
      * @return the parameter's float value, or the default value if the parameter is null.
      */
     public static float getFloatParam(final ServletRequest request, final String param, final float defValue) {
         float retval = defValue;
         String sFloat = getParameter(request, param);
         if (sFloat != null) {
             sFloat = sFloat.trim();
             if (sFloat.length() > 0) {
                 try {
                     retval = Float.parseFloat(sFloat);
                 } catch (NumberFormatException e) {
                     logger.info("RequestUtil.getFloatParam. Param {} had unparseable value '{}'.", param, sFloat);
 
                 }
             }
         }
 
         logger.debug("RequestUtil.getFloatParam for {}: {}.", param, retval);
 
         return retval;
     }
 
     /**
      * Sanitize request parameter to remove CR/LF values
      *
      * @param parameter the String to sanitize
      * @return a new String object with any CR/LF characters removed or null when the provided argument is null
      */
     @Nullable
     public static String sanitizeParameter(String parameter) {
         return (null == parameter ? null : parameter.replaceAll("[\n\r]", "_"));
     }
 
     /**
      * Sanitize request parameters to remove CR/LF values
      *
      * @param parameters the String[] to sanitize
      * @return a new String[] object with any CR/LF characters removed
      */
     public static String[] sanitizeParameters(String[] parameters) {
         List<String> sanitizedParameters = new ArrayList<>();
         if (null != parameters) {
             for (String parameter : parameters) {
                 sanitizedParameters.add(sanitizeParameter(parameter));
             }
         }
         return sanitizedParameters.toArray(new String[0]);
     }
 
     /**
      * Sanitize request parameters to remove CR/LF values
      *
      * @param parameters the List String to sanitize
      * @return a new List String object with any CR/LF characters removed
      */
     public static List<String> sanitizeParametersStringList(List<String> parameters) {
         List<String> sanitizedParameters = new ArrayList<>();
         if (null != parameters) {
             for (String parameter : parameters) {
                 sanitizedParameters.add(sanitizeParameter(parameter));
             }
         }
         return sanitizedParameters;
     }
 }