package cc.smtweb.framework.core.util;


import org.apache.commons.lang3.StringUtils;

import java.nio.charset.StandardCharsets;
import java.text.Collator;
import java.text.DecimalFormat;
import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * User: AKhh
 * Date: 12-12-24 下午5:09
 * To change this template use File | Settings | File Templates.
 */
@SuppressWarnings("UnusedDeclaration")
public class StringUtil {
    private static DecimalFormat df2Format = new DecimalFormat("###,###,###,###,##0.00");

    private static Collator chineseCollator = Collator.getInstance(Locale.CHINA);

    public static boolean isEmpty(String str) {
        return str == null || str.trim().length() == 0 || "-".equals(str);
    }

    public static boolean isNotEmpty(String cs) {
        return !isEmpty(cs);
    }


    /**
     * strSrc中寻找第一个strSe并且返回以其分隔的Left部分，汉字长度也为1
     *
     * @param strSrc 源字符串
     * @param strSe  分割字符
     * @return String 返回
     */
    public static String getLeft(String strSrc, String strSe) {
        if (isEmpty(strSrc))
            return "";
        if (isEmpty(strSe))
            strSe = " ";

        String result = "";
        int pos = strSrc.indexOf(strSe);
        if (pos >= 0)
            result = strSrc.substring(0, pos);
        return result;
    }

    /**
     * 返回字符串的左边部分，汉字长度也为1
     *
     * @param strSrc 源串,如果为空，则返回“”；
     * @param count  要获取的右边字符串长度,负数将返回“”，如果count>字符串长度，则返回整个字符串；
     * @return String return
     */
    public static String getLeft(String strSrc, int count) {
        if (isEmpty(strSrc) || count <= 0) {
            return "";
        }
        if (strSrc.length() < count) {
            return strSrc;
        } else {
            return strSrc.substring(0, count);
        }
    }

    /**
     * strSrc中寻找第一个strSe并且返回以其分隔的Right部分,汉字长度也为1
     *
     * @param strSrc 源串
     * @param strSe  分隔符,一个字符
     * @return String right部分
     */
    public static String getRight(String strSrc, String strSe) {
        if (isEmpty(strSrc))
            return "";
        if (isEmpty(strSe))
            strSe = " ";

        String result = strSrc;
        int pos = strSrc.indexOf(strSe);
        if (pos >= 0)
            result = strSrc.substring(pos + strSe.length());
        return result;
    }

    /**
     * 返回字符串的右边部分，汉字长度也为1
     *
     * @param strSrc 源串
     * @param count  要获取的右边字符串长度,负数将返回“”，如果count>字符串长度，则返回整个字符串；
     * @return String return
     */
    public static String getRight(String strSrc, int count) {
        if (isEmpty(strSrc) || count <= 0) {
            return "";
        }
        int l = strSrc.length();
        if (l <= count) {
            return strSrc;
        }
        return strSrc.substring(l - count);
    }

    /**
     * 左边补齐字符
     *
     * @param src    源串
     * @param pad    补齐字符
     * @param length 最终长度
     * @return 补齐后的字符串
     */
    public static String padLeft(String src, String pad, int length) {
        StringBuilder sb = new StringBuilder(repeatString(pad, length));
        sb.append(src);
        return sb.substring(sb.length() - length);
    }

    public static String padLeft(long src, String pad, int length) {
        StringBuilder sb = new StringBuilder(repeatString(pad, length));
        sb.append(src);
        return sb.substring(sb.length() - length);
    }

    public static String padRight(String src, String pad, int length) {
        StringBuilder sb = new StringBuilder(length * pad.length() + src.length());
        sb.append(src).append(repeatString(pad, length));
        return sb.substring(0, length);
    }

    public static String padRight(long src, String pad, int length) {
        StringBuilder sb = new StringBuilder(length * pad.length());
        sb.append(src).append(repeatString(pad, length));
        return sb.substring(0, length);
    }

    /**
     * 由于jdk1.3提供的replace函数不能满足替换要求，自己写一个
     *
     * @param src  源串
     * @param oldS 将...
     * @param newS 替换成...
     * @return 替换后的字符串
     */
    public static String replaceString(String src, String oldS, String newS) {
        StringBuilder ret = new StringBuilder(64);
        int pos = src.indexOf(oldS);
        while (pos >= 0) {
            ret.append(src.substring(0, pos)).append(newS);
            src = src.substring(pos + oldS.length());
            pos = src.indexOf(oldS);
        }
        ret.append(src);
        return ret.toString();
    }

    /**
     * 取得指定字符串左边的有效数字,首先去掉两边空格
     *
     * @param s 源串
     * @return 串左边的有效数字
     */
    public static String getStringLeftNumber(String s) {
        String ret = "";
        int dotCount = 0;
        s = s.trim();
        char[] carr = s.toCharArray();
        for (char aCarr : carr) {
            if (Character.isDigit(aCarr)) {
                ret += aCarr;
            } else if (aCarr == '.' && dotCount == 0) {
                ret += aCarr;
                dotCount++;
            } else {
                break;
            }
        }
        if (ret.endsWith(".")) {
            ret = ret.substring(0, ret.length() - 1);
        }
        return ret;
    }

    /**
     * 获取浮点数(有错误默认为0)，可以识别金额中的逗号格式
     *
     * @param str 带转换的字符串
     * @return 浮点数
     */
    public static double getDoubleIgnoreErr(String str) {
        if (str == null)
            return 0.0;
        str = str.trim();
        if (str.equals(""))
            return 0.0;
        str = str.replaceAll(",", "").replaceAll("，", "");
        try {
            return Double.valueOf(str);
        } catch (Exception e) {
            return 0.0;
        }
    }

    /**
     * 得到int 获取转换的int值，有错返回0
     *
     * @param str 带转换的字符串
     * @return int
     */
    public static int getIntIgnoreErr(String str) {
        return getIntIgnoreErr(str, 0);
    }

    public static int getIntIgnoreErr(String str, int defValue) {
        if (str == null)
            return defValue;
        str = str.trim();
        if (str.equals(""))
            return defValue;
        str = str.replaceAll(",", "").replaceAll("，", "");
        if (str.contains("."))
            str = str.substring(0, str.indexOf('.'));
        try {
            return Integer.valueOf(str);
        } catch (Exception e) {
            return defValue;
        }
    }

    /**
     * 取得重复字串
     *
     * @param repeatString 重复字串
     * @param count        重复次数
     * @return String
     */
    public static String repeatString(String repeatString, int count) {
        if (count <= 0) return "";
        StringBuilder ret = new StringBuilder(repeatString.length() * count);
        for (int i = 1; i <= count; i++) {
            ret.append(repeatString);
        }
        return ret.toString();
    }

    /**
     * 去除字符串左边的指定字符串
     *
     * @param src 源字符串
     * @param cut 要去掉的字符串；
     * @return 处理结果
     */
    public static String cutStringLeft(String src, String cut) {
        if (isEmpty(src) || isEmpty(cut)) {
            return "";
        }
        if (src.startsWith(cut)) {
            return cutStringLeft(src.substring(cut.length()), cut);
        } else {
            return src;
        }
    }

    public static String cutStringRight(String src, String cut) {
        if (isEmpty(src) || isEmpty(cut)) {
            return "";
        }
        while (src.endsWith(cut))
            src = src.substring(0, src.length() - cut.length());

        return src;
    }

    /**
     * Removes all spaces from a string
     * 可以替换大部分空白字符， 不限于空格,\s 可以匹配空格、制表符、换页符等空白字符的其中任意一个
     */
    public static String removeSpaces(String str) {
        return str.replaceAll("\\s*", "");
    }

    /**
     * Creates a single string from a List of strings seperated by a delimiter.
     *
     * @param list  a list of strings to join
     * @param delim the delimiter character(s) to use. (null value will join with no delimiter)
     * @return a String of all values in the list seperated by the delimiter
     */
    public static String join(Collection<? extends Object> list, String delim) {
        if (list == null || list.size() < 1)
            return null;
        StringBuffer buf = new StringBuffer();
        Iterator i = list.iterator();

        while (i.hasNext()) {
            buf.append(i.next().toString());
            if (i.hasNext())
                buf.append(delim);
        }
        return buf.toString();
    }


    public static String join(String[] list, String delim) {
        return join(Arrays.asList(list), delim);
    }

    /**
     * Splits a String on a delimiter into a List of Strings.
     *
     * @param str   the String to split
     * @param delim the delimiter character(s) to join on (null will split on whitespace)
     * @return a list of Strings
     */
    public static List<String> split(String str, String delim) {
        List<String> splitList = new ArrayList<>();
        StringTokenizer st;
        if (str == null)
            return splitList;

        if (delim != null)
            st = new StringTokenizer(str, delim);
        else
            st = new StringTokenizer(str);

        while (st.hasMoreTokens()) {
            splitList.add(st.nextToken());
        }
        return splitList;
    }

    //是否为true,(1,y,true,yes)
    public static boolean toBoolean(String v) {
        return "1".equals(v) || "y".equalsIgnoreCase(v) || "true".equalsIgnoreCase(v) || "yes".equalsIgnoreCase(v);
    }

    public static int chineseCompare(String s1, String s2) {
        return chineseCollator.compare(s1, s2);
    }

    /**
     * 按照编码级次，得到类型的真实编码，主要用于like 'parentCode%'
     * getSplitTypeCode('GF82000',2, 2, 1) == GF82
     * getSplitTypeCode('GF82100',3, 2, 1) == GF821
     * getSplitTypeCode('82100'  ,3, 0, 1) == 821
     *
     * @param curLevel   当前编码的所在层次
     * @param startIndex 数字编码的开始选项
     * @param perSize    每层的数字编码长度
     */
    public static String getRealCode(String code, int curLevel, int startIndex, int perSize) {
        StringBuilder sb = new StringBuilder(code.length());
        if (startIndex > 0) sb.append(code.substring(0, startIndex));
        for (int i = startIndex, l = 0; i < code.length(); i += perSize) {
            if (l < curLevel) {
                sb.append(code.substring(i, i + perSize));
                ++l;
            } else {
                break;
            }
        }
        return sb.toString();
    }

    //函数功能: 正整数
    public static boolean isPureNumber(String inputString) {
        return inputString.matches("^[1-9]\\d*$");
    }

    //函数功能: 整数
    public static boolean isNumber(String inputString) {
        return inputString.matches("^[-+][0-9]\\d*$");
    }

    //函数功能: 浮点数
    public static boolean isAmount(String inputString) {
        return inputString.matches("^[-+]?[\\d,]+(\\.\\d+)?$");
    }

    //函数功能: 带千分号的整数
    public static boolean isFormatNumber(String inputString) {
        return inputString.matches("^[-+]?[\\d,]+(\\d+)?$");
    }


    //首字母大写
    public static String upFirst(String s) {
        return s.substring(0, 1).toUpperCase() + s.substring(1);
    }

    public static String padRightBytes(String src, String pad, int length) {
        length -= src.replaceAll("[^\\x00-\\xff]", "**").length();
        return src + repeatString(pad, length);
    }

    //按字节数取子串，begin不是按字节的
    public static String substrByte(String src, int begin, int len) {
        StringBuilder sb = new StringBuilder(32);
        char c;
        int tl = src.length();
        for (int i = begin; i < len + begin && i < tl; i++) {

            c = src.charAt(i);
            sb.append(c);
            if (String.valueOf(c).replaceAll("[^\\x00-\\xff]", "**").length() > 1) {
                // 遇到中文汉字，截取字节总数减1
                --len;
            }
        }
        return sb.toString();
    }

    /**
     * 通配符算法。 可以匹配"*"和"?"
     * 如a*b?d可以匹配aAAAbcd
     *
     * @param pattern 匹配表达式
     * @param str     匹配的字符串
     * @return
     */
    public static boolean match(String pattern, String str) {
        if (pattern == null || str == null)
            return false;

        boolean result = false;
        char c; // 当前要匹配的字符串
        boolean beforeStar = false; // 是否遇到通配符*
        int back_i = 0;// 回溯,当遇到通配符时,匹配不成功则回溯
        int back_j = 0;
        int i, j;
        for (i = 0, j = 0; i < str.length(); ) {
            if (pattern.length() <= j) {
                if (back_i != 0) {// 有通配符,但是匹配未成功,回溯
                    beforeStar = true;
                    i = back_i;
                    j = back_j;
                    back_i = 0;
                    back_j = 0;
                    continue;
                }
                break;
            }

            if ((c = pattern.charAt(j)) == '*') {
                if (j == pattern.length() - 1) {// 通配符已经在末尾,返回true
                    result = true;
                    break;
                }
                beforeStar = true;
                j++;
                continue;
            }

            if (beforeStar) {
                if (str.charAt(i) == c) {
                    beforeStar = false;
                    back_i = i + 1;
                    back_j = j;
                    j++;
                }
            } else {
                if (c != '?' && c != str.charAt(i)) {
                    result = false;
                    if (back_i != 0) {// 有通配符,但是匹配未成功,回溯
                        beforeStar = true;
                        i = back_i;
                        j = back_j;
                        back_i = 0;
                        back_j = 0;
                        continue;
                    }
                    break;
                }
                j++;
            }
            i++;
        }

        if (i == str.length() && j == pattern.length())// 全部遍历完毕
            result = true;
        return result;
    }

    //填充变量
    public static String myReplaceStrEx(String express, String b, String e, IStrHanlder hanlder) {
        if (null == express) return express;
        int keyBegin = 0, keyEnd = 0;
        int lb = b.length(), le = e.length();
        String fn;
        while (true) {
            keyBegin = express.indexOf(b, keyBegin);
            if (keyBegin < 0) break;
            keyEnd = express.indexOf(e, keyBegin);
            if (keyEnd <= keyBegin) break;
            keyBegin++;
            fn = express.substring(keyBegin + lb - 1, keyEnd);
            fn = hanlder.work(fn);
            if (fn != null) {
                express = express.substring(0, keyBegin - 1) + fn + express.substring(keyEnd + le);
            }
        }
        return express;
    }

    //填充变量
    public static String myReplaceStrEx(String express, String b, String e, final Map<String, String> mapVals) {
        return myReplaceStrEx(express, b, e, new IStrHanlder() {
            @Override
            public String work(String src) {
                return checkNull(mapVals.get(src));
            }
        });
    }

    public static int compareStr(String s1, String s2) {
        if (StringUtils.isEmpty(s1) && StringUtils.isEmpty(s2)) return 0;
        if (StringUtils.isEmpty(s1)) return -1;
        if (StringUtils.isEmpty(s2)) return 1;
        return chineseCollator.compare(s1, s2);
    }

    public static boolean isStrEquals(String s1, String s2) {
        return compareStr(s1, s2) == 0;
    }

    //获取字段字符串长度
    public static int getStrLenB(String s) {
        if (StringUtils.isEmpty(s)) return 0;
        return s.getBytes(StandardCharsets.UTF_8).length;
    }

    public static boolean strToBool(String s) {
        return "true".equalsIgnoreCase(s) || "1".equals(s) || "y".equalsIgnoreCase(s);
    }

    /**
     * 功能：null过滤，返回默认值
     *
     * @param strValue     带检查的字符串
     * @param defaultValue 为空返回的字符串
     * @return str
     */
    public static String checkNull(String strValue, String defaultValue) {
        return strValue == null ? defaultValue : strValue;
    }

    /**
     * Func:为空，返回""
     *
     * @param str 带检查的字符串
     * @return ""
     */
    public static String checkNull(String str) {
        if (isEmpty(str))
            return "";
        return str.trim();
    }

    /*Blob转String*/
//    public static String blob2Str(Blob blob) {
//        if (blob == null) return "";
//        ByteArrayOutputStream outStream = null;
//        try {
//            long len = blob.length();
//            if (len == 0L) return "";
//            byte[] bytes;
//            long i = 1L;
//            outStream = new ByteArrayOutputStream();
//            while (i < len) {
//                bytes = blob.getBytes(i, 1024);
//                i += 1024L;
//                outStream.write(bytes);
//            }
//
//            return UtilEncode.base64EncodeB(outStream.toByteArray());
//        } catch (Exception e) {
//            e.printStackTrace();
//            return "";
//        } finally {
//            IOUtils.closeQuietly(outStream);
//        }
//    }


    public interface IStrHanlder {
        String work(String src);
    }

    public static int[] splitStr(String src, String ch) {
        String[] ss = src.split(ch);
        int[] ret = new int[ss.length];
        for (int i = 0, len = ss.length; i < len; i++) {
            ret[i] = NumberUtil.getIntIgnoreErr(ss[i]);
        }
        return ret;
    }

    public static void main(String[] args) {
        String s = "a[#[#123#]bcde[aaa]bcd";
        s = myReplaceStrEx(s, "[#", "#]", new IStrHanlder() {
            @Override
            public String work(String src) {
                if (src.equals("123")) return "1";
                return null;
            }
        });
        System.out.println(s);
    }
}
