package org.jr.util;

/**
 * Copyright: Copyright (c) 2002-2004
 * Company: JavaResearch(http://www.javaresearch.org)
 * 最后更新日期:2003年3月31日
 * @author Cherami
 */

import java.io.*;
import java.util.*;
import java.text.*;

/**
 * 此类中封装一些常用的字符串操作。
 * 所有方法都是静态方法，不需要生成此类的实例，
 * 为避免生成此类的实例，构造方法被申明为private类型的。
 * @since  0.1
 */
public class StringUtil {
  /**
   * 私有构造方法，防止类的实例化，因为工具类不需要实例化。
   */
  private StringUtil() {
  }

  /**
   * 此方法将给出的字符串source使用delim划分为单词数组。
   * @param source 需要进行划分的原字符串
   * @param delim 单词的分隔字符串
   * @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组，
   *         如果delim为null则使用逗号作为分隔字符串。
   * @since  0.1
   */
  public static String[] split(String source, String delim) {
    String[] wordLists;
    if (source == null) {
      wordLists = new String[1];
      wordLists[0] = source;
      return wordLists;
    }
    if (delim == null) {
      delim = ",";
    }
    StringTokenizer st = new StringTokenizer(source, delim);
    int total = st.countTokens();
    wordLists = new String[total];
    for (int i = 0; i < total; i++) {
      wordLists[i] = st.nextToken();
    }
    return wordLists;
  }

  /**
   * 此方法将给出的字符串source使用delim划分为单词数组。
   * @param source 需要进行划分的原字符串
   * @param delim 单词的分隔字符
   * @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组。
   * @since  0.2
   */
  public static String[] split(String source, char delim) {
    return split(source, String.valueOf(delim));
  }

  /**
   * 此方法将给出的字符串source使用逗号划分为单词数组。
   * @param source 需要进行划分的原字符串
   * @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组。
   * @since  0.1
   */
  public static String[] split(String source) {
    return split(source, ",");
  }

  /**
   * 循环打印字符串数组。
   * 字符串数组的各元素间以指定字符分隔，如果字符串中已经包含指定字符则在字符串的两端加上双引号。
   * @param strings 字符串数组
   * @param delim 分隔符
   * @param out 打印到的输出流
   * @since  0.4
   */
  public static void printStrings(String[] strings, String delim,
                                  OutputStream out) {
    try {
      if (strings != null) {
        int length = strings.length - 1;
        for (int i = 0; i < length; i++) {
          if (strings[i] != null) {
            if (strings[i].indexOf(delim) > -1) {
              out.write( ("\"" + strings[i] + "\"" + delim).getBytes());
            }
            else {
              out.write( (strings[i] + delim).getBytes());
            }
          }
          else {
            out.write("null".getBytes());
          }
        }
        if (strings[length] != null) {
          if (strings[length].indexOf(delim) > -1) {
            out.write( ("\"" + strings[length] + "\"").getBytes());
          }
          else {
            out.write(strings[length].getBytes());
          }
        }
        else {
          out.write("null".getBytes());
        }
      }
      else {
        out.write("null".getBytes());
      }
      out.write(Constants.LINE_SEPARATOR.getBytes());
    }
    catch (IOException e) {

    }
  }

  /**
   * 循环打印字符串数组到标准输出。
   * 字符串数组的各元素间以指定字符分隔，如果字符串中已经包含指定字符则在字符串的两端加上双引号。
   * @param strings 字符串数组
   * @param delim 分隔符
   * @since  0.4
   */
  public static void printStrings(String[] strings, String delim) {
    printStrings(strings, delim, System.out);
  }

  /**
   * 循环打印字符串数组。
   * 字符串数组的各元素间以逗号分隔，如果字符串中已经包含逗号则在字符串的两端加上双引号。
   * @param strings 字符串数组
   * @param out 打印到的输出流
   * @since  0.2
   */
  public static void printStrings(String[] strings, OutputStream out) {
    printStrings(strings, ",", out);
  }

  /**
   * 循环打印字符串数组到系统标准输出流System.out。
   * 字符串数组的各元素间以逗号分隔，如果字符串中已经包含逗号则在字符串的两端加上双引号。
   * @param strings 字符串数组
   * @since  0.2
   */
  public static void printStrings(String[] strings) {
    printStrings(strings, ",", System.out);
  }

  /**
   * 将字符串中的变量使用values数组中的内容进行替换。
   * 替换的过程是不进行嵌套的，即如果替换的内容中包含变量表达式时不会替换。
   * @param prefix 变量前缀字符串
   * @param source 带参数的原字符串
   * @param values 替换用的字符串数组
   * @return 替换后的字符串。
   *         如果前缀为null则使用“%”作为前缀；
   *         如果source或者values为null或者values的长度为0则返回source；
   *         如果values的长度大于参数的个数，多余的值将被忽略；
   *         如果values的长度小于参数的个数，则后面的所有参数都使用最后一个值进行替换。
   * @since  0.2
   */
  public static String getReplaceString(String prefix, String source,
                                        String[] values) {
    String result = source;
    if (source == null || values == null || values.length < 1) {
      return source;
    }
    if (prefix == null) {
      prefix = "%";
    }

    for (int i = 0; i < values.length; i++) {
      String argument = prefix + Integer.toString(i + 1);
      int index = result.indexOf(argument);
      if (index != -1) {
        String temp = result.substring(0, index);
        if (i < values.length) {
          temp += values[i];
        }
        else {
          temp += values[values.length - 1];
        }
        temp += result.substring(index + 2);
        result = temp;
      }
    }
    return result;
  }

  /**
   * 将字符串中的变量（以“%”为前导后接数字）使用values数组中的内容进行替换。
   * 替换的过程是不进行嵌套的，即如果替换的内容中包含变量表达式时不会替换。
   * @param source 带参数的原字符串
   * @param values 替换用的字符串数组
   * @return 替换后的字符串
   * @since  0.1
   */
  public static String getReplaceString(String source, String[] values) {
    return getReplaceString("%", source, values);
  }

  /**
   * 字符串数组中是否包含指定的字符串。
   * @param strings 字符串数组
   * @param string 字符串
   * @param caseSensitive 是否大小写敏感
   * @return 包含时返回true，否则返回false
   * @since  0.4
   */
  public static boolean contains(String[] strings, String string,
                                 boolean caseSensitive) {
    for (int i = 0; i < strings.length; i++) {
      if (caseSensitive == true) {
        if (strings[i].equals(string)) {
          return true;
        }
      }
      else {
        if (strings[i].equalsIgnoreCase(string)) {
          return true;
        }
      }
    }
    return false;
  }

  /**
   * 字符串数组中是否包含指定的字符串。大小写敏感。
   * @param strings 字符串数组
   * @param string 字符串
   * @return 包含时返回true，否则返回false
   * @since  0.4
   */
  public static boolean contains(String[] strings, String string) {
    return contains(strings, string, true);
  }

  /**
   * 不区分大小写判定字符串数组中是否包含指定的字符串。
   * @param strings 字符串数组
   * @param string 字符串
   * @return 包含时返回true，否则返回false
   * @since  0.4
   */
  public static boolean containsIgnoreCase(String[] strings, String string) {
    return contains(strings, string, false);
  }

  /**
   * 将字符串数组使用指定的分隔符合并成一个字符串。
   * @param array 字符串数组
   * @param delim 分隔符，为null的时候使用""作为分隔符（即没有分隔符）
   * @return 合并后的字符串
   * @since  0.4
   */
  public static String combineStringArray(String[] array, String delim) {
    int length = array.length - 1;
    if (delim == null) {
      delim = "";
    }
    StringBuffer result = new StringBuffer(length * 8);
    for (int i = 0; i < length; i++) {
      result.append(array[i]);
      result.append(delim);
    }
    result.append(array[length]);
    return result.toString();
  }

  /**
   * 以指定的字符和长度生成一个该字符的指定长度的字符串。
   * @param c 指定的字符
   * @param length 指定的长度
   * @return 最终生成的字符串
   * @since  0.6
   */
  public static String fillString(char c,int length) {
    String ret = "";
    for (int i=0; i<length; i++) {ret += c;}
    return ret;
  }

  /**
   * 去除左边多余的空格。
   * @param value 待去左边空格的字符串
   * @return 去掉左边空格后的字符串
   * @since  0.6
   */
  public static String trimLeft(String value) {
    String result = value;
    if(result == null) return result;
    char ch[] = result.toCharArray();
    int index = -1;
    for(int i=0; i < ch.length ; i++) {
      if(Character.isWhitespace(ch[i])) {
        index = i;
      }
      else {
        break;
      }
    }
    if(index != -1) {
      result = result.substring(index+1);
    }
    return result;
  }

  /**
   * 去除右边多余的空格。
   * @param value 待去右边空格的字符串
   * @return 去掉右边空格后的字符串
   * @since  0.6
   */
  public static String trimRight(String value) {
    String result = value;
    if(result == null) return result;
    char ch[] = result.toCharArray();
    int endIndex = -1;
    for(int i=ch.length-1; i > -1; i--) {
      if(Character.isWhitespace(ch[i])) {
        endIndex = i;
      }
      else {
        break;
      }
    }
    if(endIndex != -1) {
      result = result.substring(0, endIndex);
    }
    return result;
  }

  /**
   * 根据转义列表对字符串进行转义。
   * @param source 待转义的字符串
   * @param escapeCharMap 转义列表
   * @return 转义后的字符串
   * @since  0.6
   */
  public static String escapeCharacter(String source, HashMap escapeCharMap) {
    if (source == null || source.length() == 0) return source;
    if (escapeCharMap.size() == 0) return source;
    StringBuffer sb = new StringBuffer();
    StringCharacterIterator sci = new StringCharacterIterator(source);
    for (char c = sci.first(); c != StringCharacterIterator.DONE; c = sci.next()) {
      String character = String.valueOf(c);
      if (escapeCharMap.containsKey(character))
        character = (String)escapeCharMap.get(character);
      sb.append(character);
    }
    return sb.toString();
  }
  /**
   * 得到字符串的字节长度。
   * @param source 字符串
   * @return 字符串的字节长度
   * @since  0.6
   */
  public static int getByteLength(String source){
   int len = 0;
   for(int i=0;i<source.length();i++){
    char c = source.charAt(i);
    int highByte = c >>> 8;
    len += highByte==0?1:2;
   }
   return len;
  }
  /**
   * 得到字符串中的子串的个数。
   * @param source 字符串
   * @param sub 子串
   * @return 字符串中的子串的个数
   * @since  0.6
   */
  public static int getSubtringCount(String source,String sub) {
    if (source == null || source.length() == 0) {
      return 0;
    }
    int count=0;
    int index=source.indexOf(sub);
    while (index>=0) {
      count++;
      index=source.indexOf(sub,index+1);
    }
    return count;
  }
}