package com.oqpo.api.util;

import java.math.BigDecimal;
import java.security.SecureRandom;
import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.Random;
import java.util.UUID;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 개요 : 공통 문자열 처리 유틸 클래스
 */
public class StringUtil {

    /**
     * <pre>
     * 인자로 받은 String이 null일 경우 &quot;&quot;로 리턴한다.
     * &#064;param src null값일 가능성이 있는 String 값.
     * &#064;return 만약 String이 null 값일 경우 &quot;&quot;로 바꾼 String 값.
     * </pre>
     */
    public static String nullConvert(Object src) {
        // if (src != null &&
        // src.getClass().getName().equals("java.math.BigDecimal")) {
        if (src != null && src instanceof BigDecimal) {
            return ((BigDecimal) src).toString();
        }

        if (src == null || src.equals("null")) {
            return "";
        } else {
            return ((String) src).trim();
        }
    }

    public static int str2int(String org, int converted) {
        if (org == null || org.trim().equals("")) {
            return converted;
        } else {
            converted = Integer.parseInt(org);
        }
        return converted;
    }

    /**
     * 개요 : 입력받은 값이 null인 경우 혹은 내용이 없을 경우 대체문구로 변경한다. 입력값 : null인지 검토하고자 하는 값, 변환하고자 하는 값 출력값 : 변환값 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토한다. 2. 만약 빈 값이라면 대체문자열을 반환한다. 3. 만약 빈 값이 아니라면 trim 처리후 반환한다.
     */
    public static String null2str(String org, String converted) {
        if (org == null || org.trim().equals(""))
            return converted;
        else
            return org.trim();
    }

    /**
     * 개요 : 입력받은 값이 null인 경우 값이 없는 스트링으로 반환한다. 입력값 : 검토하고자 하는 문자열 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토후 null이면 값이 없는 스트링을 반환한다.
     */
    public static String null2str(String org) {
        return StringUtil.null2str(org, "");
    }

    /**
     * 개요 : 입력받은 객체가 null인 경우 값이 없는 스트링으로 반환한다. 입력값 : null 여부를 검토하고자 하는 객체 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토후 null이면 값이 없는 스트링을 반환한다.
     */
    public static String null2str(Object org) {
        if (org != null && org instanceof BigDecimal) {
            return StringUtil.null2str((BigDecimal) org, "");
        } else {
            return StringUtil.null2str((String) org, "");
        }
    }

    /**
     * 개요 : 입력받은 객체가 null인 경우 대체문구로 변경한다. 입력값 : null인지 검토받고자 하는 객체, 변환하고자 하는 문자열 출력값 : 변환값 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토한다. 2. 만약 빈 값이라면 대체문자열을 반환한다. 3. 만약 빈 값이 아니라면 문자로 변환후 반환처리
     */
    public static String null2str(BigDecimal org, String converted) {
        if (org == null)
            return converted;
        else
            return org.toString();
    }

    /**
     * 개요 : 입력받은 객체가 null인 경우 값이 없는 문자열로 반환. 입력값 : null인지 검토받고자 하는 객체 출력값 : 변환값 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토한다. 2. 만약 빈 값이라면 빈문자열을 반환한다.
     */
    public static String null2str(BigDecimal org) {
        return StringUtil.null2str(org, "");
    }

    /**
     * 개요 : 입력받은 객체가 null인 경우 기본숫자형으로 반환. 입력값 : null인지 검토받고자 하는 객체 출력값 : 변환값 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토한다. 2. 만약 빈 값이라면 defaultNum을 반환한다.
     */
    public static int null2int(Object inObj, int defaultNum) {
        try {
            String inStr = (inObj != null ? String.valueOf(inObj) : "0");
            inStr = StringUtil.getExtractNumberInChar(inStr);
            if (StringUtil.realLen(inStr) > 0) {
                return Integer.parseInt(inStr);
            } else {
                return defaultNum;
            }
        } catch (Exception e) {
            return defaultNum;
        }
    }

    /**
     * 개요 : 입력받은 객체가 null인 경우 기본숫자형으로 반환. 입력값 : null인지 검토받고자 하는 객체 출력값 : 변환값 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토한다. 2. 만약 빈 값이라면 defaultNum을 반환한다.
     */
    public static long null2long(Object inObj, long defaultNum) {
        try {
            String inStr = (inObj != null ? String.valueOf(inObj) : "0");
            inStr = StringUtil.getExtractNumberInChar(inStr);
            if (StringUtil.realLen(inStr) > 0) {
                return Long.parseLong(inStr);
            } else {
                return defaultNum;
            }
        } catch (Exception e) {
            return defaultNum;
        }
    }

    /**
     * 개요 : 입력받은 객체의 실제 길이를 리턴 값이 없을경우 0을 리턴 입력값 : 실제길이를 구할 스트링 문자열 출력값 : 변환값 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토한다. 2. 만약 빈 값이라면 0을 반환 아님 trim()한 실제 길이를 리턴한다.
     */
    public static int realLen(String inStr) {
        int realLen = 0;
        if (inStr != null && inStr.trim().length() > 0) {
            realLen = inStr.trim().length();
        } else {
            realLen = 0;
        }

        return realLen;
    }

    /**
     * 개요 : 입력받은 문자열을 YYYY/MM/DD의 날짜 형태로 변환처리한다. 입력값 : 변환하고자 하는 문자열. 출력값 : 변환된 문자열 처리내용 : 1. 입력받은 값이 null인지를 확인하고 null이면 반환 2. 문자열이 8자리가 되지 않는다면 입력받은 * 문자열 반환 3. 문자열을 YYYY/MM/DD 형태로 변환 후 반환
     */
    public static String toDateStr(String dateStr) {
        String transDate = "";
        if (dateStr == null) {
            return transDate;
        } else if (dateStr.length() == 8) {
            transDate = dateStr.substring(0, 4) + "/" + dateStr.substring(4, 6) + "/" + dateStr.substring(6, 8);
        } else if (dateStr.length() == 12) {
            transDate = dateStr.substring(0, 4) + "-" + dateStr.substring(4, 6) + "-" + dateStr.substring(6, 8) + " " + dateStr.substring(8, 10) + ":" + dateStr.substring(10, 12);
        }
        return transDate;
    }

    /**
     * 개요 : 입력받은 문자열을 yyyy/MM/dd HH:mm:ss의 날짜 형태로 변환처리한다. 입력값 : 변환하고자 하는 문자열. 출력값 : 변환된 문자열. 처리내용 : 1. 입력받은 값이 null인지를 확인하고 null이면 반환 2. 문자열을 yyyy/MM/dd HH:mm:ss 한국 시간 형태로 변환 후 반환
     */
    public static String toDateStr(Timestamp date) {
        if (date == null)
            return "";
        else {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss", Locale.getDefault());
            return sdf.format(new Date(date.getTime()));
        }
    }

    /**
     * 개요 : 입력받은 문자열을 주민등록 형태로 변환처리 입력값 : 변환하고자 하는 문자열 출력값 : 변환된 문자열 처리내용 : 1. 입력받은 값이 null인지를 확인하고 null이면 반환 2. 입력받은 문자열이 14자리가 아니라면 반환 3. 문자열을 xxxxxx-xxxxxxx의 주민등록 번호 형태로 변환 후 반환
     */
    public static String toSsnStr(String ssnStr) {
        if (ssnStr == null)
            return "";
        else if (ssnStr.length() != 13)
            return ssnStr;
        else
            return ssnStr.substring(0, 6) + "-" + ssnStr.substring(6, 13);
    }

    /**
     * 개요 : 입력받은 문자열을 데이터 베이스 네이밍 룰 형태로 전환처리한다. 입력값 : 변환하고자 하는 문자열 출력값 : 변환된 문자열 처리내용 : 1. 입력받은 값의 char 중 byte 41보다 작은 값이 있으면 '_' 을 붙여준 후 반환한다.
     */
    public static String toDBField(String field) {

        StringBuffer sb = new StringBuffer();
        String temp;

        for (int i = 0; i < field.length(); i++) {
            temp = field.substring(i, i + 1);
            if (temp.getBytes()[0] < 'a') {
                sb.append("_");
                sb.append(temp.toLowerCase());
            } else {
                sb.append(temp);
            }
        }
        return sb.toString();
    }

    /**
     * 개요 : DB key를 생성하기 위해 입력 받은 number를 Lpad 하여 String으로 반환 입력값 : inNum = 변환하기 위한 수 : chPad = 패딩을 채우기 위한 문자 : intLength = 패딩해야 할 자리수 출력값 : 변환한 문자열 처리내용 : 입력받은 숫자를 패딩처리 후 반환
     */
    public static String numberToStringLPad(int inNum, char chPad, int intLength) {

        String strNum = inNum + "";
        int inValLength = strNum.length();

        if (inValLength >= intLength) {
            return inNum + "";
        }

        StringBuffer strBuf = new StringBuffer();
        String strResult = "";

        int paddingCnt = intLength - inValLength;
        for (int i = 0; i < paddingCnt; i++) {
            strBuf.append(chPad);
        }
        strResult = strBuf.append(strNum).toString();
        return strResult;
    }

    /**
     * 개요 : 입력받은 문자열을 Hexa 형태로 변환 처리 입력값 : 변환하고자 하는 문자열 출력값 : 변환한 문자열 처리내용 : 1. 입력받은 값을 Long Type으로 변환 처리 2. 입력받은 문자열을 Hexa 문자열 형태로 변환 후 반환
     */
    public static String stringToHexa(String input) throws Exception {
        long dValue = Long.parseLong(input);
        String value = Long.toHexString(dValue);
        String hexStr = value.substring(0, value.length() - 1).toUpperCase();
        return (hexStr.length() != 15 ? "0" + hexStr : hexStr); // return
        // Long.toHexString(dValue).toUpperCase();
    }

    /**
     * 개요 : 입력받은 문자열을 HexaCode인지 확인 입력값 : 확인하고자 하는 문자열 출력값 : true or false 처리내용 : 1. 입력받은 문자열 내에 16진수가 아닌것이 있는지를 검토한다.
     */
    public static boolean isHex(String hexNum) {
        boolean isResult = true;
        char[] inputArry = hexNum.toCharArray();

        for (int i = 0; i < inputArry.length; i++) {
            int intConv = Character.digit(inputArry[i], 16);
            if (intConv < 0) {
                return false;
            }
        }
        return isResult;
    }

    /**
     * 개요 : 입력받은 문자열을 Decimal 형태로 변환 처리 입력값 : 변환하고자 하는 문자열 출력값 : 변환한 문자열 처리내용 : 1. 입력받은 값을 Long Type으로 변환 처리 2. 입력받은 문자열을 Decimal 문자열 형태로 변환 후 반환
     */
    public static long binToDec(String bin) {
        long decNum = 0;

        for (int inx = 0; inx < bin.length(); inx++) {
            decNum = decNum * 2 + Integer.parseInt(bin.substring(inx, inx + 1));
        }

        return decNum;
    }

    /**
     * 개요 : 입력받은 문자를 LPadding처리한다. 입력값 : 입력받은 Hexa 형태의 문자열의 맨 뒷부분 '0'를 빼고 보충하고자하는 입력받은 문자를 을 이용하여 15리로 LPadding처리 처리내용 : 1. 입력받은 값이 null인지 혹은 빈값인지를 검토후 null이면 값이 없는 스트링을 반환한다. 2. 입력받은 문자열의 마지막 문자가 0인지를 검토 후 0이면 제거 3. 보충하고자 하는 입력받은 문자로
     * LPadding처리 후 반
     */
    public static String zeroLPadString(int inNum, String value, char chrPad) {
        String output = "";
        // 입력값이 널인지 아닌지를 검토
        if (value == null || value.length() < 1) {
            return output;
        }

        // 맨 뒷자가 0인지 검토
        if (value.lastIndexOf("0") == value.length() - 1) {
            value = value.substring(0, value.length() - 1);
        }

        int paddingNum = inNum - value.length();
        // padding 시작
        String strPadding = "";
        for (int i = 0; i < paddingNum; i++) {
            strPadding = strPadding + chrPad;
        }
        output = value + strPadding;
        return output;
    }

    /**
     * 개요 : 입력받은 문자열을 알팟벳 형태로 변환 처리 입력값 : 변환하고자 하는 문자열 출력값 : 변환한 문자열 처리내용 : 1. 입력받은 값을 Long Type으로 변환 처리 2. 입력받은 문자열을 알파벳 형태로 변환 후 반환
     */
    public static String ToAlpabet(int sNum) {
        String sAlpabet = "";

        switch (sNum) {
            case 1:
                sAlpabet = "A";
                break;
            case 2:
                sAlpabet = "B";
                break;
            case 3:
                sAlpabet = "C";
                break;
            case 4:
                sAlpabet = "D";
                break;
            case 5:
                sAlpabet = "E";
                break;
            case 6:
                sAlpabet = "F";
                break;
            case 7:
                sAlpabet = "G";
                break;
            case 8:
                sAlpabet = "H";
                break;
            case 9:
                sAlpabet = "I";
                break;
            case 10:
                sAlpabet = "J";
                break;
            case 11:
                sAlpabet = "K";
                break;
            case 12:
                sAlpabet = "L";
                break;
            case 13:
                sAlpabet = "M";
                break;
            case 14:
                sAlpabet = "N";
                break;
            case 15:
                sAlpabet = "O";
                break;
            case 16:
                sAlpabet = "P";
                break;
            case 17:
                sAlpabet = "Q";
                break;
            case 18:
                sAlpabet = "R";
                break;
            case 19:
                sAlpabet = "S";
                break;
            case 20:
                sAlpabet = "T";
                break;
            case 21:
                sAlpabet = "U";
                break;
            case 22:
                sAlpabet = "V";
                break;
            case 23:
                sAlpabet = "W";
                break;
            case 24:
                sAlpabet = "X";
                break;
        }

        return sAlpabet;
    }

    /**
     * 개요 : 입력받은 byte[]을 byte[start]부터 len 개수만큼 잘라서 String 반환한다. 입력값 : byte[],배열 시작지점,반환할 문자의 길이. 출력값 : byte[]에서 길이만큼 잘라낸 값 String 반환. 처리내용 : 1. 입력받은 byte[]배열값을 for문을 통해 입력받은 시작점부터 len길이 만큼 잘라서 targe[] 담는다.
     */
    public static String byteToSubString(byte[] bytes, int start, int len) {
        String subStr = "";
        try {
            byte[] target = new byte[len];

            for (int inx = 0; inx < len; inx++) {
                target[inx] = bytes[start + inx];
            }

            subStr = new String(target);
        } catch (Exception e) {
            // NOTING TO DO
        }

        return subStr;
    }

    /**
     * 개요 : 입력받은 문자열을 Binary 형태로 변환 처리 입력값 : 변환하고자 하는 문자열 출력값 : 변환한 문자열 처리내용 : 1. 입력받은 문자열의 각 문자를 2진수로 변환 철리 후 반환
     */
    public static String toBinary(String hexNum) throws Exception {
        String binNum = "";
        char[] inputArry = hexNum.toCharArray();
        for (int i = 0; i < inputArry.length; i++) {

            int intConv = Character.digit(inputArry[i], 16);
            binNum = binNum + StringUtil.numberToStringLPad(Integer.parseInt(Integer.toBinaryString(intConv)), '0', 4);
        }
        return binNum;
    }

    /**
     * 개요 : 입력받은 값을 대체문구로 변경한다. 입력값 : 변환하고자 하는 값(DataType : int) 출력값 : 변환값 처리내용 : 1. 입력받은 값을 계산 형식 을 이용하여 대체 문구로 변경합니다.
     */
    public static String toBinary(int num) throws Exception {
        String convString = "";
        convString = StringUtil.toBinary(Integer.toHexString(num).toUpperCase());
        return convString;
    }

    /**
     * 개요 : 입력받은 값을 unsigned형식으로 변경한다. 입력값 : 변환하고자 하는 값(DataType : long) 출력값 : 변환값 처리내용 : 1. 입력받은 값을 unsigned형식으로 변경합니다.
     */
    public static long unsigned32(long n) {
        return n & 0xFFFFFFFFL;
    }

    /**
     * 개요 : 입력받은 문자열이 숫자로만 이루어져 있는지 확인 후 true, false반환. 입력값 : 체크 할 입력 문자열(inStr) 출력값 : true, false 처리내용 : 1. 입력받은 문자열이 수자로만 이루어져 있는지 확인 후 true, false반환. 2. '-'가 있는것은 숫자로 간주한다.
     */
    public static boolean isNumberStr(String inStr) {
        boolean bl = false;
        for (int i = 0; i < inStr.length(); i++) {
            char compCh = inStr.charAt(i);
            if ((0x30 <= compCh && compCh <= 0x39) || compCh == 0x2d || compCh == 0x2c) {
                bl = true;
            } else {
                bl = false;
                break;
            }
        }
        return bl;
    }

    /**
     * 개요 : 입력받은 문자열이 숫자로만 이루어져 있는지 확인 후 true, false반환. 입력값 : 체크 할 입력 문자열(inStr) 출력값 : true, false 처리내용 : 1. 입력받은 문자열이 수자로만 이루어져 있는지 확인 후 true, false반환.
     */
    public static boolean isOnlyNumberStr(String inStr) {
        boolean bl = false;
        for (int i = 0; i < inStr.length(); i++) {
            char compCh = inStr.charAt(i);
            if ((0x30 <= compCh && compCh <= 0x39)) {
                bl = true;
            } else {
                bl = false;
                break;
            }
        }
        return bl;
    }

    public static boolean isDoubleStr(String inStr) {
        boolean result = false;

        try {
            Double.parseDouble(inStr);
            result = true;
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 개요 : 입력받은 값(숫자형식으로 된 문자열)을 천단위마다 ,를 찍는다. 입력값 : 변환하고자 하는 값(inStr) 출력값 : 변환값 처리내용 : 1. 입력받은 값을 천단위마다 ,를 찍는다. 2. - 부호가 붙었을경우 '-'를 없애고 변환한 후 '-'붙인다.
     */
    public static String getAddCommaStr(Object inObj) {
        String outStr = "";
        if (String.valueOf(inObj).indexOf(".0") > -1)
            inObj = String.valueOf(inObj).replaceAll("[.]0", "");
        if (String.valueOf(inObj) != null && realLen(String.valueOf(inObj)) > 0) {
            if (isNumberStr(String.valueOf(inObj))) {
                if (String.valueOf(inObj).indexOf("-") > -1) {
                    if (realLen(String.valueOf(inObj)) > 1)
                        outStr = "-" + new DecimalFormat("#,###").format(Long.parseLong(String.valueOf(inObj).replaceAll("-", "").replaceAll(",", "")));
                    else
                        return String.valueOf(inObj);
                } else {
                    outStr = new DecimalFormat("#,###").format(Long.parseLong(String.valueOf(inObj).replaceAll("[,]", "")));
                }
            }
        } else {
            return String.valueOf(inObj);
        }
        return outStr;
    }

    /**
     * 개요 : 소수점있는 숫자열 천단위 ,넣기 입력값 : 변환하고자 하는 값(inStr) 출력값 : 변환값 처리내용 : 1. 입력받은 값을 천단위마다 ,를 찍는다. 2. - 부호가 붙었을경우 '-'를 없애고 변환한 후 '-'붙인다.
     */
    public static String getAddCommaStrForDecimalPoint(Object inObj) {
        String outStr = "";
        if (String.valueOf(inObj) != null && realLen(String.valueOf(inObj)) > 0) {
            if (String.valueOf(inObj).indexOf("-") > -1) {
                if (realLen(String.valueOf(inObj)) > 1)
                    outStr = "-" + new DecimalFormat("#,##0.00").format(Double.parseDouble(String.valueOf(inObj).replaceAll("-", "")));
                else
                    return String.valueOf(inObj);
            } else {
                outStr = new DecimalFormat("#,##0.0").format(Double.parseDouble(String.valueOf(inObj)));
            }
        } else {
            return String.valueOf(inObj);
        }
        return outStr;
    }

    /**
     * 개요 : 입력받은 Vector 객체의 내용을 String[] 형태로 반환 입력값 : 바뀌어야할 Vector 출력값 : 변환값 처리내용 : 입력받은 백터의 내용을 String[] 형태로 변환 후 반환
     */
    public static String[] convertStringArray(Vector<String> vec) {
        String[] conv = new String[vec.size()];

        for (int i = 0; i < vec.size(); i++) {
            conv[i] = vec.get(i);
        }
        return conv;
    }

    /**
     * 개요 : 입력받은 double형의 숫자를 자리수를 정하여 반올림하여 반환한다. 입력값 : double형의 문자열( inDbl : 입력문자열, roundIdx : 반올림 할 자릿 수) 출력값 : 반올림 된 double형의 문자열
     */
    public static double getRoundForNumber(double inDbl, int roundIdx) {
        return Double.parseDouble(String.format("%." + roundIdx + "f", inDbl));
    }

    /**
     * 개요 : 입력받은 double형의 숫자를 자리수를 정하여 버림하여 반환한다. 입력값 : double형의 문자열( inDbl : 입력문자열, roundIdx : 버림 할 자릿 수) 출력값 : 반올림 된 double형의 문자열
     */
    public static double getDownForNumber(double inDbl, int roundIdx) {

        BigDecimal bD0 = new BigDecimal(inDbl);
        String strDbl = bD0.setScale(roundIdx, BigDecimal.ROUND_DOWN) + "";
        return Double.parseDouble(strDbl);
    }

    /**
     * 개요 : 입력받은 double형의 숫자를 자리수를 정하여 올림하여 반환한다. 입력값 : double형의 문자열( inDbl : 입력문자열, roundIdx : 올림 할 자릿 수) 출력값 : 반올림 된 double형의 문자열
     */
    public static double getUpForNumber(double inDbl, int roundIdx) {

        BigDecimal bD0 = new BigDecimal(inDbl);
        String strDbl = bD0.setScale(roundIdx, BigDecimal.ROUND_UP) + "";
        return Double.parseDouble(strDbl);
    }

    /**
     * 개요 : 입력받은 String형의 숫자를 자리수를 정하여 올림하여 반환한다. 입력값 : double형의 문자열( inDbl : 입력문자열, roundIdx : 올림 할 자릿 수) 출력값 : 반올림 된 double형의 문자열
     */
    public static double getUpForNumberString(String inDbl, int roundIdx) {

        BigDecimal bD0 = new BigDecimal(inDbl);
        String strDbl = bD0.setScale(roundIdx, BigDecimal.ROUND_UP) + "";
        return Double.parseDouble(strDbl);
    }

    /**
     * 개요 : 입력받은 문자열에서 숫자 또는 '-'만 추출해 append하여 반환한다. 입력값 : 숫자만 추출 할 입력 문자열 출력값 : 숫자로 구성된 문자열
     */
    public static String getExtractNumberInChar(String inStr) {
        StringBuffer sb = new StringBuffer("");
        for (int i = 0; i < inStr.length(); i++) {
            // 비교할 문자가 0 ~ 9사이 또는 '-' 이면 append
            if (0x30 <= inStr.charAt(i) && inStr.charAt(i) <= 0x39 || inStr.charAt(i) == 0x2d)
                sb.append(inStr.charAt(i));
        }
        return sb.toString();
    }

    /**
     * 개요 : 입력받은 문자열을 지정된 자리수 만큼 특정 문자열을 왼쪽에 채운다. 입력값 : left padding처리 할 문자열 출력값 : left padding처리된 문자열
     */
    public static String leftPad(String str, int len, char pad) {
        String result = str;
        int templen = len - result.length();

        if (templen <= 0)
            return result;

        for (int i = 0; i < templen; i++)
            result = pad + result;

        return result;
    }

    /**
     * 개요 : 입력받은 문자열을 지정된 자리수 만큼 특정 문자열을 오른쪽에 채운다. 입력값 : right padding처리 할 문자열 출력값 : right padding처리된 문자열
     */
    public static String rightPad(String str, int len, char pad) {
        String result = str;
        int templen = len - result.length();

        if (templen <= 0)
            return result;

        for (int i = 0; i < templen; i++)
            result = result + pad;

        return result;
    }

    /**
     * 개요 : 입력받은 문자열이 더블형인 경우 소수점 자리수까지 표시해준다. 입력값 : 소수점 표현할 문자식 출력값 : right padding처리된 문자열 사용예 : 1.2 -> 1.20으로 표시
     */
    public static String strRoundTail(String str, int roundIdx) {
        String result = str;

        if (str.indexOf(".") > -1) {
            // 1.00
            int pos = str.indexOf(".");
            String headStr = str.substring(0, pos + 1);
            String tailStr = str.substring(pos + 1, str.length());
            tailStr = rightPad(tailStr, roundIdx, '0');
            result = headStr + tailStr;
        } else if (str.indexOf("-") > -1) {
            result = str;
        } else {
            result = str + ".";
            result = result + rightPad("", roundIdx, '0');
        }
        return result;
    }

    public static int parseInt(String src) {

        if (src == null || src.equals("null") || "".equals(src) || " ".equals(src)) {
            return -1;
        } else {
            return Integer.parseInt(src.trim());
        }
    }

    /**
     * <p>
     * String이 비었거나("") 혹은 null 인지 검증한다.
     * </p>
     *
     * <pre>
     *  StringUtil.isEmpty(null)      = true
     *  StringUtil.isEmpty("")        = true
     *  StringUtil.isEmpty(" ")       = false
     *  StringUtil.isEmpty("bob")     = false
     *  StringUtil.isEmpty("  bob  ") = false
     * </pre>
     *
     * @param str - 체크 대상 스트링오브젝트이며 null을 허용함
     * @return <code>true</code> - 입력받은 String 이 빈 문자열 또는 null인 경우
     */
    public static boolean isEmpty(String str) {
        return str == null || str.length() == 0;
    }

    public static String printMoneyFormat(int money) {
        DecimalFormat formatter = new DecimalFormat("#,###");
        return formatter.format(money);
    }

    public static int randInt(int min, int max) {
        Random rand = new Random();
        int randomNum = rand.nextInt((max - min) + 1) + min;
        return randomNum;
    }

    public static String getPayment(double chargeAmt, String api_locale) {
        String result = String.format("%.2f", chargeAmt);

        if ("kr".equals(api_locale)) {
            result = Integer.toString((int) Math.floor(chargeAmt));
        }

        return result;
    }

    public static String getParm(String val) {
        if (val == null)
            val = "";
        return val;
    }

    public static String getUuid() {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
        String today = formatter.format(new Date());
        String uuid = today + "0-" + UUID.randomUUID().toString();
        return uuid;
    }

    public static String getUuid(int seq) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
        String today = formatter.format(new Date());
        String uuid = today + seq + "-" + UUID.randomUUID().toString();
        return uuid;
    }

    public static String getUuid32() {
        return UUID.randomUUID().toString().replace("-", "");
    }

    public static String makeSecureString(int length) {
        if (length < 4) {
            length = 6;
        }
        final char[] allAllowed = "abcdefghijklmnopqrstuvwxyzABCDEFGJKLMNPRSTUVWXYZ0123456789".toCharArray();

        Random random = new SecureRandom();
        StringBuilder password = new StringBuilder();

        for (int i = 0; i < length; i++) {
            password.append(allAllowed[random.nextInt(allAllowed.length)]);
        }
        return password.toString();
    }

    public static String makeCouponNo(int length) {
        if (length < 4) {
            length = 6;
        }
        final char[] allAllowed = "abcdefghijklmnopqrstuvwxyz0123456789".toCharArray();

        Random random = new SecureRandom();
        StringBuilder password = new StringBuilder();

        for (int i = 0; i < length; i++) {
            password.append(allAllowed[random.nextInt(allAllowed.length)]);
        }
        return password.toString();
    }

    public static String makeBarcodeNo() {
        final char[] allAllowed = "0123456789".toCharArray();

        Random random = new SecureRandom();
        StringBuilder password = new StringBuilder();

        for (int i = 0; i < 10; i++) {
            password.append(allAllowed[random.nextInt(allAllowed.length)]);
        }
        return "082" + password.toString();
    }

    public static boolean isValidEmail(String email) {
        boolean err = false;
        String regex = "^[_a-z0-9-]+(.[_a-z0-9-]+)*@(?:\\w+\\.)+\\w+$";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(email);
        if (m.matches()) {
            err = true;
        }
        return err;
    }

    public static String printPhoneFormat(String src) {
        if (src == null) {
            return "";
        }
        if (src.length() == 8) {
            return src.replaceFirst("^([0-9]{4})([0-9]{4})$", "$1-$2");
        } else if (src.length() == 12) {
            return src.replaceFirst("(^[0-9]{4})([0-9]{4})([0-9]{4})$", "$1-$2-$3");
        }
        return src.replaceFirst("(^02|[0-9]{3})([0-9]{3,4})([0-9]{4})$", "$1-$2-$3");
    }

    public static void main(String[] args) throws Exception {
        System.out.println(makeSecureString(16) + ", " + makeSecureString(32));
        System.out.println(removeSpecialChar("가#,!나다라^~^;"));
    }

    /**
     * 특수문자 제거 개요 : 입력받은 String을 정규식(match)에 맞는 규칙으로 replaceAll 후 String 반환한다. 입력값 : string
     */
    public static String removeSpecialChar(String str) {
        String match = "[^\u3131-\u314e\u314f-\u3163\u2E80-\u2EFF\u3040-\u309F?\u30A0-\u30FF\u30F0-\u31FF\u3200-\u32FF\u3400-\u4DBF\u4E00-\u9FFF\uAC00-\uD7A3xfe0-9a-zA-Z\\+\\&\\%\\.\\_\\(\\)\\/\\s\u007E]";
        str = str.replaceAll(match, "");
        str = str.replaceAll("[\\r\\n]", "");
        str = str.replaceAll("\\t", " ");
        return str;
    }

    /**
     * 전화번호 정규식 변환 개요 : 입력받은 String을 전화번호 정규식(match)에 맞는 규칙으로 replaceFirst 후 String 반환한다. 입력값 : string
     */
    public static String setPhoneFormat(String phone) {
        if (phone == null) {
            return "";
        }
        if (phone.length() == 8) {
            return phone.replaceFirst("^([0-9]{4})([0-9]{4})$", "$1-$2");
        } else if (phone.length() == 12) {
            return phone.replaceFirst("(^[0-9]{4})([0-9]{4})([0-9]{4})$", "$1-$2-$3");
        }
        return phone.replaceFirst("(^02|[0-9]{3})([0-9]{3,4})([0-9]{4})$", "$1-$2-$3");
    }

}