/*
 * $Id: StringUtil.java,v 1.0 2016/07/19 03:22:21 wangqx Exp $
 */
package cn.com.liandisys.ycjt.ggcx.common.util;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

/**
 * @author wangqx 2016-7-19
 */
public class StringUtil extends org.apache.commons.lang.StringUtils {

    /**
     * 转换null字符串对象为""字符串
     * 
     * @param str
     * @return
     */
    public static String nullToEmptyStr(String str) {
        if (StringUtils.isEmpty(str)) return "";
        return str;
    }

    /**
     * 转换null对象为""字符
     * 
     * @param str
     * @return
     */
    public static String nullToEmptyStr(Object obj) {
        return nullToEmptyStr(obj == null ? null : String.valueOf(obj));
    }

    /**
     * 转换sql中的转义字符
     * 
     * @param oriSql
     * @return
     */
    public static String convertSqlEscapeChar(String oriSql) {
        return oriSql.replaceAll("%", "\\\\%").replaceAll("_", "\\\\_");
    }

    /**
     * 如果字符串为空则转换成空字符串，否则原串返回
     * 
     * @param str
     * @return
     */
    public static String convertNullToEmpty(String str) {
        if (isNotEmpty(str)) {
            return str;
        } else {
            return EMPTY;
        }
    }

    public static String convertNullToString(Integer i) {
        if (i == null) {
            return EMPTY;
        } else {
            return i.toString();
        }
    }

    public static String replaceDotToColon(String str) {
        if (StringUtils.isEmpty(str)) return str;
        return str.replaceAll("\\.", ":");
    }

    public static String replaceColonToDot(String str) {
        if (StringUtils.isEmpty(str)) return str;
        return str.replaceAll(":", ".");
    }

    public static boolean isIn(String target, String... strings) {
        for (String str : strings) {
            if (target == str) {
                return true;
            }
        }
        return false;
    }

    public static boolean isIgnoreCaseIn(String target, String... strings) {
        for (String str : strings) {
            if (target == str || (isNotEmpty(target) && target.equalsIgnoreCase(str))) {
                return true;
            }
        }
        return false;
    }

    /**
     * TRUE:1
     */
    public static final Character TRUE_CHARACTER = '1';

    /**
     * 是否为真
     * 
     * @param c
     *            字符
     * @return 真假
     */
    public static boolean isTrue(Character c) {
        if (TRUE_CHARACTER.equals(c)) {
            return true;
        }
        return false;

    }

    /**
     * 是否为真
     * 
     * @param s
     *            字符
     * @return 真假
     */
    public static boolean isTrue(String s) {
        if (TRUE_CHARACTER.equals(s)) {
            return true;
        }
        return false;
    }

    /**
     * 追加双引号
     * 
     * @param str
     *            字符
     * @return 追加后字符
     */
    public static String quote(String str) {
        return str == null ? null : (new StringBuilder('"')).append(str).append('"').toString();
    }

    /**
     * 追加单引号
     * 
     * @param str
     *            字符
     * @return 追加后字符
     */
    public static String singleQuote(String str) {
        return str == null ? null : (new StringBuilder("'")).append(str).append("'").toString();
    }

    /**
     * 替换文本
     * 
     * @param text
     *            处理文本
     * @param placeholder
     *            占位符
     * @param parameters
     *            替换参数
     * @return 替换后文本
     */
    public static String replace(String text, String placeholder, String... parameters) {
        if (!StringUtils.isEmpty(text) && !StringUtils.isEmpty(placeholder) && parameters != null) {
            for (String parameter : parameters) {
                text = replaceOnce(text, placeholder, parameter);
            }
        }
        return text;
    }

    /**
     * 替换文本
     * 
     * @param text
     *            处理文本
     * @param placeholder
     *            占位符
     * @param parameters
     *            替换参数
     * @return 替换后文本
     */
    public static String replace(String text, Character placeholder, String... parameters) {
        return replace(text, placeholder + StringUtils.EMPTY, parameters);
    }

    /**
     * 替换文本
     * 
     * @param text
     *            处理文本
     * @param placeholder
     *            占位符
     * @param parameters
     *            替换参数
     * @return 替换后文本
     */
    public static String replace(String text, Character placeholder, List<String> parameters) {
        return replace(text, placeholder + StringUtils.EMPTY, parameters);
    }

    /**
     * 替换文本
     * 
     * @param text
     *            处理文本
     * @param placeholder
     *            占位符
     * @param parameters
     *            替换参数
     * @return 替换后文本
     */
    public static String replace(String text, String placeholder, List<String> parameters) {
        if (parameters != null && parameters.size() > 0) {
            return replace(text, placeholder, parameters.toArray(new String[parameters.size()]));
        }
        return text;
    }

    /**
     * 取得指定长度的数字字符组合
     * 
     * @param length
     *            长度
     * @return 数字字符
     */
    public static String getRandomChar(int length) {
        String val = "";
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            // 输出字母还是数字
            String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
            // 字符串
            if ("char".equalsIgnoreCase(charOrNum)) {
                // 取得大写字母还是小写字母
                int choice = random.nextInt(2) % 2 == 0 ? 65 : 97;
                val += (char) (choice + random.nextInt(26));
            } else if ("num".equalsIgnoreCase(charOrNum)) {
                // 数字
                val += String.valueOf(random.nextInt(10));
            }
        }
        return val;
    }

    /**
     * 解析参数
     * 
     * @param str
     *            字符串
     * @param regex
     *            表达式
     * @return 解析后的参数列表
     * @throws Exception
     *             异常
     */
    public static List<String> parseParams(String str, String regex) throws Exception {
        List<String> params = new ArrayList<String>();
        Matcher matcher = Pattern.compile(regex).matcher(str);
        while (matcher.find()) {
            params.add(matcher.group());
        }
        return params;
    }

    public static boolean isEmpty(Object value) {
        if (value == null) return true;
        if (isEmpty(value.toString())) return true;
        return false;
    }

    /**
     * 获取随机字符串
     * 
     * @param length
     * @return
     */
    public static String getRandomString(int length) { // length表示生成字符串的长度
        String base = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(base.length());
            sb.append(base.charAt(number));
        }
        return sb.toString();
    }

    /**
     * 隐藏电话号码
     * 
     * @param str
     *            字符串
     * @return 处理后的电话号码
     */
    public static String replacePhoneNo(String phoneNo) {
        String resultStr = phoneNo;

        if (!phoneNo.isEmpty() && phoneNo.length() >= 7) {
            char tempStr[] = new char[phoneNo.length()];
            for (int i = 0; i < phoneNo.length(); i++) {
                switch (i) {
                case 3:
                    tempStr[i] = '*';
                    break;
                case 4:
                    tempStr[i] = '*';
                    break;
                case 5:
                    tempStr[i] = '*';
                    break;
                case 6:
                    tempStr[i] = '*';
                    break;
                default:
                    tempStr[i] = phoneNo.charAt(i);
                }
            }
            resultStr = String.valueOf(tempStr);
        }
        return resultStr;
    }
}
