package com.foxinmy.weixin4j.util;
   
   import java.nio.charset.Charset;
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
   import java.util.StringTokenizer;
   
   public final class StringUtil {
  
  	public static final String EMPTY = "";
  	public static final int INDEX_NOT_FOUND = -1;
  
  	private static byte[] getBytes(final String content, final Charset charset) {
  		if (content == null) {
  			return null;
  		}
  		return content.getBytes(charset);
  	}
  
  	private static String newString(final byte[] bytes, final Charset charset) {
  		return bytes == null ? null : new String(bytes, charset);
  	}
  
  	public static byte[] getBytesUtf8(final String content) {
  		return getBytes(content, Consts.UTF_8);
  	}
  
  	public static String newStringUtf8(final byte[] bytes) {
  		return newString(bytes, Consts.UTF_8);
  	}
  
  	public static boolean isEmpty(final CharSequence cs) {
  		return cs == null || cs.length() == 0;
  	}
  
  	public static boolean isBlank(final CharSequence cs) {
  		int strLen;
  		if (cs == null || (strLen = cs.length()) == 0) {
  			return true;
  		}
  		for (int i = 0; i < strLen; i++) {
  			if (Character.isWhitespace(cs.charAt(i)) == false) {
  				return false;
  			}
  		}
  		return true;
  	}
  
  	public static boolean isNotBlank(final CharSequence cs) {
  		return !isBlank(cs);
  	}
  
  	public static String uncapitalize(final String str) {
  		int strLen;
  		if (str == null || (strLen = str.length()) == 0) {
  			return str;
  		}
  
  		char firstChar = str.charAt(0);
  		if (Character.isLowerCase(firstChar)) {
  			// already uncapitalized
  			return str;
  		}
  
  		return new StringBuilder(strLen).append(Character.toLowerCase(firstChar)).append(str.substring(1)).toString();
  	}
  
  	public static String capitalize(final String str) {
  		int strLen;
  		if (str == null || (strLen = str.length()) == 0) {
  			return str;
  		}
  
  		char firstChar = str.charAt(0);
  		if (Character.isTitleCase(firstChar)) {
  			// already capitalized
  			return str;
  		}
  		return new StringBuilder(strLen).append(Character.toTitleCase(firstChar)).append(str.substring(1)).toString();
  	}
  
  	public static String substringBefore(final String str, final String separator) {
  		if (isEmpty(str) || separator == null) {
  			return str;
  		}
  		if (separator.isEmpty()) {
  			return EMPTY;
  		}
  		final int pos = str.indexOf(separator);
  		if (pos == INDEX_NOT_FOUND) {
  			return str;
  		}
  		return str.substring(0, pos);
  	}
  
  	public static String substringAfter(final String str, final String separator) {
  		if (isEmpty(str)) {
  			return str;
 		}
 		if (separator == null) {
 			return EMPTY;
 		}
 		final int pos = str.indexOf(separator);
 		if (pos == INDEX_NOT_FOUND) {
 			return EMPTY;
 		}
 		return str.substring(pos + separator.length());
 	}
 
 	public static String join(final Object[] array, final char separator) {
 		if (array == null) {
 			return null;
 		}
 		return join(array, separator, 0, array.length);
 	}
 
 	public static String join(final Object[] array, final char separator, final int startIndex, final int endIndex) {
 		if (array == null) {
 			return null;
 		}
 		final int noOfItems = endIndex - startIndex;
 		if (noOfItems <= 0) {
 			return EMPTY;
 		}
 		final StringBuilder buf = new StringBuilder(noOfItems * 16);
 		for (int i = startIndex; i < endIndex; i++) {
 			if (i > startIndex) {
 				buf.append(separator);
 			}
 			if (array[i] != null) {
 				buf.append(array[i]);
 			}
 		}
 		return buf.toString();
 	}
 
 	public static String join(final Iterable<?> iterable, final char separator) {
 		if (iterable == null) {
 			return null;
 		}
 		return join(iterable.iterator(), separator);
 	}
 
 	public static String join(final Iterator<?> iterator, final char separator) {
 
 		// handle null, zero and one elements before building a buffer
 		if (iterator == null) {
 			return null;
 		}
 		if (!iterator.hasNext()) {
 			return EMPTY;
 		}
 		final Object first = iterator.next();
 		if (!iterator.hasNext()) {
 			return String.valueOf(first);
 		}
 
 		// two or more elements
 		final StringBuilder buf = new StringBuilder(256); // Java default is 16,
 															// probably too
 															// small
 		if (first != null) {
 			buf.append(first);
 		}
 
 		while (iterator.hasNext()) {
 			buf.append(separator);
 			final Object obj = iterator.next();
 			if (obj != null) {
 				buf.append(obj);
 			}
 		}
 
 		return buf.toString();
 	}
 
 	public static String join(final int[] array, final char separator) {
 		if (array == null) {
 			return null;
 		}
 		return join(array, separator, 0, array.length);
 	}
 
 	public static String join(final int[] array, final char separator, final int startIndex, final int endIndex) {
 		if (array == null) {
 			return null;
 		}
 		final int noOfItems = endIndex - startIndex;
 		if (noOfItems <= 0) {
 			return EMPTY;
 		}
 		final StringBuilder buf = new StringBuilder(noOfItems * 16);
 		for (int i = startIndex; i < endIndex; i++) {
 			if (i > startIndex) {
 				buf.append(separator);
 			}
 			buf.append(array[i]);
 		}
 		return buf.toString();
 	}
 
 	/**
 	 * The shortcut to {@link #simpleClassName(Class)
 	 * simpleClassName(o.getClass())}.
 	 */
 	public static String simpleClassName(Object o) {
 		if (o == null) {
 			return "null_object";
 		} else {
 			return simpleClassName(o.getClass());
 		}
 	}
 
 	/**
 	 * Generates a simplified name from a {@link Class}. Similar to
 	 * {@link Class#getSimpleName()}, but it works fine with anonymous classes.
 	 */
 	public static String simpleClassName(Class<?> clazz) {
 		if (clazz == null) {
 			return "null_class";
 		}
 
 		Package pkg = clazz.getPackage();
 		if (pkg != null) {
 			return clazz.getName().substring(pkg.getName().length() + 1);
 		} else {
 			return clazz.getName();
 		}
 	}
 
 	public static String[] tokenizeToStringArray(String str, String delimiters) {
 		return tokenizeToStringArray(str, delimiters, true, true);
 	}
 
 	public static String[] tokenizeToStringArray(String str, String delimiters, boolean trimTokens,
 			boolean ignoreEmptyTokens) {
 
 		if (str == null) {
 			return null;
 		}
 		StringTokenizer st = new StringTokenizer(str, delimiters);
 		List<String> tokens = new ArrayList<String>();
 		while (st.hasMoreTokens()) {
 			String token = st.nextToken();
 			if (trimTokens) {
 				token = token.trim();
 			}
 			if (!ignoreEmptyTokens || token.length() > 0) {
 				tokens.add(token);
 			}
 		}
 		return tokens.toArray(new String[tokens.size()]);
 	}
 }