package net.sf.jpkgmk.util;
   
   import java.io.UnsupportedEncodingException;
   import java.nio.charset.Charset;
   import java.util.Random;
   
   import net.sf.jpkgmk.ParseException;
   import net.sf.jpkgmk.prototype.PrototypeParser;
   
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * @author gommma (gommma AT users.sourceforge.net)
   * @author Last changed by: $Author: gommma $
   * @version $Revision: 2 $ $Date: 2008-08-20 21:14:19 +0200 (Mi, 20 Aug 2008) $
   * @since 1.0
   */
  public class StringUtil 
  {
      /**
       * Enumeration of supported truncation modes.
       */
      public static class TruncationMode {
          /** 
           * The mode that describes that a string is truncated at the beginning
           * and the end string is returned. 
           */
          public static final TruncationMode START = new TruncationMode();
          /** 
           * The mode that describes that a string is truncated at the end
           * and the start string is returned. 
           */
          public static final TruncationMode END = new TruncationMode();
  
      	private TruncationMode() {
      	}
      };
  
      /** The string literal for the UTF-8 character set */
      public static final String UTF8_ENCODING = "UTF-8";
  
      /** Default encoding/charset */
      public static final String DEFAULT_SYSTEM_CHARSET = Charset.defaultCharset().name();
  
  	/**
  	 * All hexadecimal characters as bytes
  	 */
  	static final byte[] HEX_CHAR_TABLE = {
  		(byte) '0', (byte) '1', (byte) '2',
  		(byte) '3', (byte) '4', (byte) '5', (byte) '6', (byte) '7',
  		(byte) '8', (byte) '9', (byte) 'a', (byte) 'b', (byte) 'c',
  		(byte) 'd', (byte) 'e', (byte) 'f' };
  
  	private static Log log = LogFactory.getLog(StringUtil.class);
  	
  	
  	
  	private StringUtil() {
  		
  	}
  	
  
  	
  	public static String getHexString(byte[] raw) throws UnsupportedEncodingException 
  	{
  	    byte[] hex = new byte[2 * raw.length];
  	    int index = 0;
  
  	    for (int i=0; i<raw.length; i++) {
  	    	byte b = raw[i];
  	    	int v = b & 0xFF;
  	    	hex[index++] = HEX_CHAR_TABLE[v >>> 4];
  	    	hex[index++] = HEX_CHAR_TABLE[v & 0xF];
  	    }
  	    return new String(hex, "ASCII");
  	}
  
  	
  	/**
  	 * @param string
  	 * @return Returns true if the given string is null or an empty string
  	 */
  	public static final boolean isNullOrEmpty(String string) {
  		return (string==null || string.trim().equals(""));
  	}
  
  	
  	/**
  	 * Replaces the first occurrence of the given 'search' string by the 'replacement' string. 
  	 * @param path The path on which the replacement should be done
  	 * @param search search string
  	 * @param replacement replacement string
  	 * @return
  	 */
  	public static final String replace(String path, String search, String replacement) 
      {
          int index = path.indexOf(search);
          if(index >= 0) {
             String result = path.substring(0, index);
             result += replacement;
             result += path.substring(index + search.length());
             return result;
         }
         else {
             // Return the original if no replacement found
             return path; 
         }
     }
 
 	
 	/**
 	 * Creates a random string with the given length
 	 * @param byteSize
 	 * @return
 	 */
 	public static String createRandomStringWithBytes(int byteSize)
 	{
 		if(byteSize <= 0) {
 			throw new IllegalArgumentException("The given byteSize '" + byteSize + "' must be > 0");
 		}
 		
 		StringBuffer sb = new StringBuffer();
 		Random random = new Random();
 		for (int i = 0; i < byteSize; i++) {
 			// ASCII alphabet fits into 7 bits, 2^7=128 -> otherwise we could get into trouble with the unicode encodings...
 			char oneByte = (char) (random.nextInt() % 128);
 			sb.append(oneByte);
 		}
 		return sb.toString();
 	}
 
 
 	public static boolean isInteger(String value) {
 		try {
 			Integer.parseInt(value);
 			return true;
 		}
 		catch(NumberFormatException e) {
 			return false;
 		}
 	}
 
 	/**
 	 * Converts the given array of strings into a single string using the given delimiter as separator.
 	 * @param array
 	 * @param delimiter
 	 * @return
 	 */
 	public static String createString(String[] array, char delimiter) {
 		return createString(array, 0, delimiter);
 	}
 
 	/**
 	 * Converts the given array of strings into a single string using the given delimiter as separator.
 	 * @param array
 	 * @param startIndex
 	 * @param delimiter
 	 * @return
 	 */
 	public static String createString(String[] array, int startIndex, char delimiter) {
 		if(startIndex >= array.length) {
 			throw new ArrayIndexOutOfBoundsException("The start index '" + startIndex + "' must be smaller than array length " + array.length);
 		}
 		
 		StringBuffer sb = new StringBuffer();
 		for(int i=startIndex; i<array.length; i++) {
 			sb.append(array[i]);
 			
 			if(i < array.length-1) {
 				sb.append(delimiter);
 			}
 		}
 		return sb.toString();
 	}
 
     /**
      * Truncates the given string if it is longer than the maximum length specified. The symbols '...'
      * replace the last three characters to indicate that truncation occurred. If the string's length is less than
      * the specified maximum, it is returned unchanged. If the given string is null, null is returned.
      * Maximum lengths of less than 1 will be ignored.
      *
      * @param inputString The string to truncate, if necessary.
      * @param maxLength The maximum length of the string, after truncation.
      *
      * @return A string at most maxLength characters long taken from the input string, or the input string if it is
      *         shorter than the specified maximum length.
      */
     public static String truncateToMaxLength(String inputString, int maxLength)
     {
         String outputString = inputString;
 
         if((inputString != null) && (maxLength > 0) && (inputString.length() > maxLength)) {
             outputString = inputString.substring(0, maxLength - 3) + "...";
         }
 
         return outputString;
     }
 
     /**
      * Returns the specified string truncated to the specified maximum length in bytes (when encoded in UTF-8
      * format), with an ellipses (...) if need be.
      *
      * @param text The text to truncate.
      * @param maxLengthInBytes The maximum length in bytes.
      * @param mode The mode for executing the truncation. This can be one of 
      * <ul>
      * <li><code>{@link StringUtil.TruncationMode#END}</code> or</li> 
      * <li><code>{@link StringUtil.TruncationMode#START}</code>. </li> 
      * </ul> If the specified mode is any unknown mode, the
      *        default mode <code>{@link StringUtil.TruncationMode#END}</code> is used.
      *
      * @return The specified string truncated to the specified maximum length in bytes.
      *
      * @throws IllegalArgumentException If maxLengthInBytes is less than 3 or if the given {@link TruncationMode} is
      *         unknown.
      */
     public static String truncateUtf8String(String text, int maxLengthInBytes, TruncationMode mode)
     {
         if(text == null) {
             throw new NullPointerException("The parameter 'text' must not be null");
         }
 
         if(maxLengthInBytes < 3) {
             throw new IllegalArgumentException("maxLengthInBytes < 3");
         }
 
         int lengthInBytes = getLengthInBytes(text, UTF8_ENCODING);
 
         // Return the input of the length looks good.
         if(lengthInBytes <= maxLengthInBytes) {
             return text;
         }
 
         // We're going to add "..." so we recompute this for good
         maxLengthInBytes = maxLengthInBytes - 3;
 
         // If there's no special characters, then one char = one byte,
         // and we do a normal truncation.
         if(lengthInBytes == text.length()) {
             if(mode == TruncationMode.START) {
                 return "..." + text.substring(text.length() - maxLengthInBytes, text.length());
             }
             else {
                 return text.substring(0, maxLengthInBytes) + "...";
             }
         }
 
         // We definitely have special characters at this point!
         if(mode == TruncationMode.START) {
         	return truncateStart(text, maxLengthInBytes);
         }
         else if(mode == TruncationMode.END) {
         	return truncateEnd(text, maxLengthInBytes);
         }
         else {
             throw new IllegalArgumentException("Unknown TruncationMode: " + mode);
         }
     }
 
     
     private static String truncateEnd(String text, int maxLengthInBytes) {
         // Truncate the end of the text so that we can append the "..."
         text = text.substring(0, maxLengthInBytes);
 
         // We recalculate the length of what we have left.
         int lengthInBytes = getLengthInBytes(text, UTF8_ENCODING);
 
         // It might be that we chopped off the special characters
         // causing the overflow and can return what we have now.
         if(lengthInBytes <= maxLengthInBytes) {
             return text + "...";
         }
 
         // Loop backwards through the string, removing the length in
         // bytes of each character from the previously calculated length.
         // When the length is under the allowable max, we return the
         // candidate.
         for(int i = text.length() - 1; i >= 0; i--) {
             lengthInBytes -= ((text.charAt(i) > 127) ? 2 : 1);
 
             //		    	System.out.println("char at " + i + " = '" + text.charAt(i) +
             //		        "', length of '" + text.substring(0, i) + "' is " + lengthInBytes);
             if(lengthInBytes <= maxLengthInBytes) {
                 return text.substring(0, i) + "...";
             }
         }
 
         // We should never arrive here
         throw new IllegalStateException("Should never reach here");
     }
 
 
 
 	private static String truncateStart(String text, int maxLengthInBytes) {
         // Truncate the start of the text so that we can append the "..."
         text = text.substring(text.length() - maxLengthInBytes, text.length());
 
         // We recalculate the length of what we have left.
         int lengthInBytes = getLengthInBytes(text, UTF8_ENCODING);
 
         // It might be that we chopped off the special characters
         // causing the overflow and can return what we have now.
         if(lengthInBytes <= maxLengthInBytes) {
             return "..." + text;
         }
 
         // Loop forwards through the string, removing the length in
         // bytes of each character from the previously calculated length.
         // When the length is under the allowable max, we return the
         // candidate.
         for(int i = 0; i < text.length(); i++) {
             lengthInBytes -= ((text.charAt(i) > 127) ? 2 : 1);
 
             //		    	System.out.println("char at " + i + " = '" + text.charAt(i) +
             //		        "', length of '" + text.substring(0, i) + "' is " + lengthInBytes);
             if(lengthInBytes <= maxLengthInBytes) {
                 return "..." + text.substring(i, text.length());
             }
         }
         
         // We should never arrive here
         throw new IllegalStateException("Should never reach here");
 	}
 
 
 
 	/**
      * Returns the length of the byte array for the specified <code>text</code>.
      *
      * @param text The text whose length in bytes should be computed.
      * @param charset The encoding of the text which is needed for converting the text to a byte array. For available
      *        encodings, refer to {@link java.nio.charset.Charset#availableCharsets()}.
      *
      * @return The length of the byte array for the text in the specified encoding. If the specified
      *         <code>charset</code> is not supported, this method returns zero.
      *
      * @throws NullPointerException If the specified string is null.
      */
     public static int getLengthInBytes(String text, String charset)
     {
         if(text == null) {
             throw new NullPointerException("The parameter 'text' must not be null!");
         }
 
         if(charset == null) {
             // get the default character set of the system
             charset = DEFAULT_SYSTEM_CHARSET;
         }
 
         try {
             return text.getBytes(charset).length;
         }
         catch(UnsupportedEncodingException encodingException) {
             log.warn("Unexpected encoding exception while converting string to " + charset + ": '"
                 + encodingException.getMessage().trim() + "'.");
             return 0;
         }
     }
 
     
     
     
 	/**
 	 * Resolves a key value pair from the given string by splitting it at the first found '=' character.
 	 * @param someString String to resolve. If the string is null or empty, a runtime exception is thrown
 	 * @return
 	 */
 	public static KeyValuePair resolveKeyValue(String someString)
 	{
 		if (someString == null) {
 			throw new NullPointerException("The parameter 'someString' must not be null");
 		}
 		
 		String key = null;
 		String value = null;
 		
 		int idxEqualSymbol = someString.indexOf(KeyValuePair.ASSIGNMENT_CHAR);
 		if(idxEqualSymbol != -1) {
 			key = someString.substring(0, idxEqualSymbol);
 			value = someString.substring(idxEqualSymbol+1);
 		}
 		else {
 			key = someString;
 		}
 
 		KeyValuePair result = new KeyValuePair(key, value);
 		return result;
 	}
 	
 	
 	
 	/**
 	 * Simple object associating a key with a value
 	 */
 	public static class KeyValuePair
 	{
 		/**
 		 * Constant for the '=' character
 		 */
 		public static final String ASSIGNMENT_CHAR = "=";
 		
 		private String key;
 		private String value;
 		
 		/**
 		 * @param key Key must not be null
 		 * @param value value can be null
 		 */
 		public KeyValuePair(String key, String value) {
 			super();
 			if (key == null) {
 				throw new NullPointerException("The parameter 'key' must not be null");
 			}
 			if(key.trim().length()<=0) {
 				throw new IllegalArgumentException("The parameter 'key' must not be an empty string.");
 			}
 			this.key = key;
 			this.value = value;
 		}
 		
 		public String getKey() {
 			return key;
 		}
 		public void setKey(String key) {
 			this.key = key;
 		}
 		public String getValue() {
 			return value;
 		}
 		public void setValue(String value) {
 			this.value = value;
 		}
 		
 		
 	}
 
 
 
 	/**
 	 * Checks if the given string is alphanumeric or not
 	 * @param stringToCheck
 	 * @return
 	 */
 	public static boolean isAlphaNumeric(String stringToCheck) {
 		if (stringToCheck == null) {
 			throw new NullPointerException(
 					"The parameter 'stringToCheck' must not be null");
 		}
 
 		char[] chr = stringToCheck.toCharArray();
 		for (int i = 0; i < chr.length; i++) {
 			if(!Character.isLetterOrDigit(chr[i])) {
 				return false;
 			}
 		}
 		return true;
 		
 //		boolean blnNumeric = false;
 //		boolean blnAlpha = false;
 //
 //		char chr[] = null;
 //		if(stringToCheck != null)
 //		chr = stringToCheck.toCharArray();
 //
 //		for(int i=0; i<chr.length; i++){
 //			if(chr[i] >= '0' && chr[i] <= '9'){
 //				blnNumeric = true;
 //				break;
 //			}
 //		}
 //		for(int i=0; i<chr.length; i++){
 //			if((chr[i] >= 'A' && chr[i] <= 'Z') || (chr[i] >= 'a' && chr[i] <= 'z')){
 //				blnAlpha = true;
 //				break;
 //			}
 //		}
 //		return (blnNumeric && blnAlpha);
 	}
 
 	public static int compare(String first, String second) {
 		if(first == null && second == null) {
 			return 0;
 		}
 		else if(first==null) {
 			return -1;
 		}
 		else {
 			return first.compareTo(second);
 		}
 	}
 
 
 	public static void validateMode(String mode) {
 		if (mode == null) {
 			throw new NullPointerException(
 					"The parameter 'mode' must not be null");
 		}
 		
 		if(mode.equals("?")) {
 			return;
 		}
 		else {
 			String regexOctal = "[0-7]{3,4}";
 			// Check if it is a valid 4 digit octal number
 			if(!mode.matches(regexOctal)) {
 				throw new ParseException("The given mode '" + mode + "' must consist of 4 valid octal numbers.");
 			}
 		}
 	}
 
 
 
 	public static RemoveResult removePrefix(String string, String prefix) {
 		// Cut off the key
 		int indexOfKey = string.indexOf(prefix);
 		boolean hasWhitespaceSeparator = false;
 		if(string.length() > indexOfKey) {
 			char nextChar = string.charAt(indexOfKey+1);
 			if(nextChar == PrototypeParser.DEFAULT_LINE_DELIMITER) {
 				hasWhitespaceSeparator = true;
 				indexOfKey++;
 			}
 		}
 		
 		String resultString = null;
 		if(string.length() > indexOfKey) {
 			resultString = string.substring(indexOfKey+1);
 		}
 		
 		return new RemoveResult(resultString, hasWhitespaceSeparator);
 	}
 	
 	
 	public static final class RemoveResult {
 		private boolean hasWhitespaceSeparator;
 		private String cleanedString;
 		
 		public RemoveResult(String cleanedString, boolean hasWhitespaceSeparator)
 		{
 			this.cleanedString = cleanedString;
 			this.hasWhitespaceSeparator = hasWhitespaceSeparator;
 		}
 		
 		public boolean isHasWhitespaceSeparator() {
 			return hasWhitespaceSeparator;
 		}
 		public void setHasWhitespaceSeparator(boolean hasWhitespaceSeparator) {
 			this.hasWhitespaceSeparator = hasWhitespaceSeparator;
 		}
 		public String getCleanedString() {
 			return cleanedString;
 		}
 		public void setCleanedString(String cleanedString) {
 			this.cleanedString = cleanedString;
 		}
 		
 	}
 
 
 }