/*
    * Copyright 2004-2005 Emmanouil Batsis
    * 
    * Licensed under the GNU General Public 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.gnu.org/licenses/gpl.txt
    * 
   * 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.
   * 
   */
  package com.geekologue.md4j.util;
  
  import java.io.UnsupportedEncodingException;
  import java.lang.reflect.Array;
  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  import java.text.SimpleDateFormat;
  import java.util.*;
  import org.apache.log4j.Logger;
  
  /***
   * @author Manos Batsis Jun 28, 2004
   */
  public class StringUtil {
      private static Logger log = Logger.getLogger(StringUtil.class);
  
      public static String getNullIfEmpty(String s) {
          return s != null && s.length() > 0 ? s : null;
      }
  
      // TODO: modify so that if string-number and greater than zero,
      // return true
      public static boolean getBoolean(Object o, boolean bDefault) {
          boolean b = bDefault;
          if (o != null) {
              if (o instanceof Boolean) {
                  b = ((Boolean) o).booleanValue();
              } else if (o instanceof Integer) {
                  b = ((Integer) o).intValue() > 0;
              } else {
                  String s = o.toString();
                  if (s.length() > 0) {
                      if (s.equalsIgnoreCase("true"))
                          b = true;
                      else if (s.equalsIgnoreCase("false"))
                          b = false;
                      else if (s.equals("1"))
                          b = true;
                      else if (s.equals("0"))
                          b = false;
                      else if (s.equalsIgnoreCase("yes"))
                          b = true;
                      else if (s.equalsIgnoreCase("no"))
                          b = false;
                      else if (s.equalsIgnoreCase("on"))
                          b = true;
                      else if (s.equalsIgnoreCase("off"))
                          b = false;
                  }
              }
          }
          return b;
      }
  
      public static Integer getInteger(String s) {
          Integer i = null;
          if (s != null && s.length() > 0) {
              try {
                  i = new Integer(s);
              } catch (NumberFormatException e) {
                  log.warn(e);
              }
          }
          return i;
      }
  
      public static Long getLong(String s) {
          Long l = null;
          if (s != null && s.length() > 0) {
              try {
                  l = new Long(s);
              } catch (NumberFormatException e) {
                  log.warn(e);
              }
          }
          return l;
      }
  
      public static Float getFloat(String s) {
          Float f = null;
          if (s != null && s.length() > 0) {
              try {
                  f = new Float(s);
             } catch (NumberFormatException e) {
                 log.error(e);
             }
         }
         return f;
     }
 
     public static Double getDouble(String s) {
         Double f = null;
         if (s != null && s.length() > 0) {
             try {
                 f = new Double(s);
             } catch (NumberFormatException e) {
                 log.error(e);
             }
         }
         return f;
     }
 
     public static Integer getIntegerOrZero(String s) {
         Integer i = getInteger(s);
         return i != null ? i : new Integer(0);
     }
 
     public static boolean equalsHash(String s, String hash, String algorithm)
             throws NoSuchAlgorithmException, UnsupportedEncodingException {
         String base64 = "";
         base64 = getHash(s);
         // log.debug("Hash Value for: "+str+"="+base64);
         return base64.equals(hash);
     }
 
     /***
      * Get an MD5 hash for the given string. <b>Note </b>: only MD5 mode has
      * been tested.
      * 
      * @param s
      *            The String to hash
      * @param algorithm
      *            The algorithm to use (see finals). If if <code>null</code>,
      *            the default will be used (MD5)
      * @return
      * @throws NoSuchAlgorithmException
      * @throws UnsupportedEncodingException
      */
     public static String getHash(String s) throws NoSuchAlgorithmException,
             UnsupportedEncodingException {
         MessageDigest md = MessageDigest.getInstance("MD5");
         md.update(s.getBytes());
         byte digest[] = md.digest();
         return toHex(digest);
     }
 
     /***
      * Get a hexadecimal String from a byte array
      * 
      * @param arr
      * @return
      */
     private static String toHex(byte[] arr) {
         final StringBuffer hexString = new StringBuffer();
         final String ZERO = "0";
         int z = 0;
         final int dig = arr.length;
         for (int i = 0; i < dig; i++) {
             z = 0xFF & arr[i];
             if (z < 16)
                 hexString.append(ZERO);
             hexString.append(Integer.toHexString(z));
         }
         return hexString.toString();
     }
 
     public static String toHex(String s) {
         return toHex(s.getBytes());
     }
 
     /***
      * Look for the occurence of a string in an array. Case insensitive.
      * 
      * @param s
      *            The string to look for
      * @param arr
      *            The array of strings to look in
      * @return True if the string is found in the array, false otherwise or if
      *         either of the arguments is null
      */
     public static boolean isInArrayIgnoreCase(String s, String[] arr) {
         boolean found = false;
         if (s != null && arr != null)
             for (int i = 0; i < arr.length && !found; i++)
                 found = s.equalsIgnoreCase(arr[i]);
         return found;
     }
 
     /***
      * Look for the occurence of a string in an array. Case sensitive.
      * 
      * @param s
      *            The string to look for
      * @param arr
      *            The array of strings to look in
      * @return True if the string is found in the array, false otherwise or if
      *         either of the arguments is null
      */
     public static boolean isInArray(String s, String[] arr) {
         boolean found = false;
         if (s != null && arr != null)
             for (int i = 0; i < arr.length && !found; i++)
                 found = s.equals(arr[i]);
         return found;
     }
 
     public static String getValueOrDefault(String s, String defaultValue) {
         return s != null ? s : defaultValue;
     }
 
     /***
      * Return the string representation of a primitive array. Uses the
      * <code>AbstractCollection.toString</code> format.
      * 
      * @param obj
      *            the array
      * @return the string representation
      */
     public static String toString(Object obj) {
         if (obj == null)
             return "null";
         if (!isArray(obj))
             throw new IllegalArgumentException("Object is not an array ");
         StringBuffer result = new StringBuffer("[");
         int length = Array.getLength(obj);
         for (int idx = 0; idx < length; ++idx) {
             Object item = Array.get(obj, idx);
             if (isNonNullArray(item)) {
                 // recursive for arrays of arrays
                 result.append(toString(item));
             } else {
                 result.append(item);
             }
             if (!isLastItem(idx, length)) {
                 result.append(", ");
             }
         }
         result.append("]");
         return result.toString();
     }
 
     private static boolean isArray(Object obj) {
         if (obj.getClass().isArray())
             return true;
         else
             return false;
     }
 
     private static boolean isNonNullArray(Object obj) {
         return obj != null && obj.getClass().isArray();
     }
 
     private static boolean isLastItem(int i, int length) {
         return (i == length - 1);
     }
 
     public static boolean isEmpty(String s) {
         boolean result = true;
         if ((s != null) && !s.trim().equals(""))
             result = false;
         return result;
     }
 
     public static String toXMLString(String str) {
         StringBuffer buffer;
         char ch;
         String entity;
         buffer = null;
         for (int i = 0; i < str.length(); i++) {
             ch = str.charAt(i);
             switch (ch) {
             case '<':
                 entity = "&lt;";
                 break;
             case '>':
                 entity = "&gt;";
                 break;
             case '&':
                 entity = "&amp;";
                 break;
             case '\"':
                 entity = "&quot;";
                 break;
             case '\'':
                 entity = "&apos;";
                 break;
             default:
                 entity = null;
                 break;
             }
             if (buffer == null) {
                 if (entity != null) {
                     // An entity occurred, so we'll have to use StringBuffer
                     // (allocate room for it plus a few more entities).
                     buffer = new StringBuffer(str.length() + 20);
                     // Copy previous skipped characters and fall through
                     // to pickup current character
                     buffer.append(str.substring(0, i));
                     buffer.append(entity);
                 }
             } else {
                 if (entity == null) {
                     buffer.append(ch);
                 } else {
                     buffer.append(entity);
                 }
             }
         }
         // If there were any entities, return the escaped characters
         // that we put in the StringBuffer. Otherwise, just return
         // the unmodified input string.
         return (buffer == null) ? str : buffer.toString();
     }
 
     /***
      * Enforce a trailing '/' or '\' depending on platform, to ensure the path
      * denotes a directory
      * 
      * @param s
      * @return
      */
     public static String enforceTrailingChar(String s, char c) {
         if (s.lastIndexOf(c) != s.length() - 1)
             s += c;
         return s;
     }
 
     /***
      * @param string
      * @return
      */
     public static Date getDate(String s) {
         Date d = null;
         try {
             SimpleDateFormat sdf = null;
             String pattern = null;
             int sepIndex;
             if (s != null) {
                 sepIndex = s.indexOf("/");
                 if (sepIndex != -1) {
                     if (sepIndex == 2) {
                         pattern = "dd/MM/yyyy";
                     } else if (sepIndex == 4) {
                         pattern = "yyyy/MM/dd";
                     }
                 } else {
                     sepIndex = s.indexOf("-");
                     if (sepIndex != -1) {
                         if (sepIndex == 2) {
                             pattern = "dd-MM-yyyy";
                         } else if (sepIndex == 4) {
                             pattern = "yyyy-MM-dd";
                         }
                     }
                 }
             }
             d = sdf.parse(s);
         } catch (Exception e) {
         }
         return d;
     }
 }