package com.eactive.eai.batch.common;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.DecimalFormat;
import java.util.StringTokenizer;

public class StringUtil
{
    /**
	 * 1. 기능 : 주어진 문자열이 숫자로만 구성되어 있는지 확인한다.
	 *           공백이 있으면 false를 반환한다.
	 * 2. 처리 개요 :
     *    - char값이 48에서 57사이이면 숫자이다.
	 *
	 * @param	str			문자열
	 * @return 	문자열이 모두 숫자로만 이루어진경우 true
	 */
	public static boolean isNumeric(String str) {
		if (str==null || str.equals("")) return false;

		for (int i=0; i<str.length(); i++) {
			if ((int)str.charAt(i) < 48 || (int)str.charAt(i) > 57) return false;
		}
		return true;
	}

    /**
	 * 1. 기능 : 주어진 문자열이 문자로만 구성되어 있는지 확인한다.
	 *           공백은 true를 반환한다.
	 * 2. 처리 개요 :
     *    - 입력된 String을 대문자로 모두 변환한다. (알파벳은 65(A)에서 90(Z)까지이다.)
     *    - char값이 65이상이면 문자이다.
	 *
	 * @param	str			문자열
	 * @return 	문자열이 모두 문자로만 이루어진경우 true
	 */
	public static boolean isAlpha(String str) {
		if (str==null || str.equals("")) return true;

		for (int i=0; i<str.length(); i++) {
			if ((int)str.charAt(i) < 65 && ((int)str.charAt(i) != 32)) return false;
		}
		return true;
	}
	
	   /**
		* 1. 기능 : 구분자가 들어간 스트링을 구분자기준으로 잘라 String Array를 만들어주는 Method
	    * 2. 처리 개요 : 
	    *     - 구분자가 들어간 스트링을 구분자기준으로 잘라 String Array를 만들어주는 Method
	    * 3. 주의사항
		*	
		*	@param inStr 대상 스트링
	    *   @param delim 잘라낼 때의 기준 구분자
	    *   @return 잘라낸 스트링을 담고 있는 String Array
		*/ 
	    public static String[] getStrArray(String inStr, String delim) {
	        String[] retStr = null;        
	        
	        if ( inStr == null || inStr.equals("") ) {
	            return (new String[] {});
	        } else {
	           retStr = inStr.split(delim); 
	        }
	        
	        return retStr;   
	    }

    /**
     * 1.기능: Delimiter로 구분된 String을 받아들여 String[]을 반환한다.
     */
    public String[] parseStringWithDelimiter(String str, String delim)
    {
        String[] rtArray = new String[getMissSeqNoCnt(str, delim.charAt(0))];
        StringTokenizer st = new StringTokenizer(str, delim);
        int i=0;
        while (st.hasMoreTokens())
        {
            rtArray[i] = st.nextToken();
        }
        return rtArray;
    }

    private int getMissSeqNoCnt(String str, char delim)
    {
        /**
         * 1.기능: 입력된 String에서 0의 갯수만 반환한다.
         */
        int patternMatchCnt = 0;

        for(int i=0; i<str.length(); i++)
        {
            if(str.charAt(i) == delim)
            {
                patternMatchCnt++;
            }
        }
        return patternMatchCnt;
    }






    public static int stoi(String s)
    {
        if(s == null || s.equals(""))
            return 0;
        else
            return Integer.valueOf(replaceStr(s, ",", "").trim()).intValue();
    }

    public static String itos(int i)
    {
        return (new Integer(i)).toString();
    }

    public static String replaceStr(String s, String s1, String s2) throws NullPointerException
    {
        if(s == null || s.length() == 0)
            return "";
        if(s1 == null || s1.equals("") || s2 == null)
            return s;
        int i = 0;
        StringBuffer stringbuffer = new StringBuffer();
        while((i = s.indexOf(s1)) >= 0)
        {
            stringbuffer.append(s.substring(0, i)).append(s2);
            s = s.substring(i + s1.length());
        }
        stringbuffer.append(s);
        return stringbuffer.toString();
    }

	public static String nvl(String str) {
		return nvl(str, "");
	}

	public static String nvl(String str, String defaultValue) {
		if (str == null || str.equals("")) return defaultValue;
		return str;
	}

	public static String nvlTrim(String str) {
		return nvlTrim(str, "");
	}

	public static String nvlTrim(String str, String defaultValue) {
		if (str == null || str.trim().equals("")) return defaultValue;
		return str.trim();
	}

	/**
	 * <pre>
	 * 문자열을 주어진 포맷으로 일치시킨다.
	 * 용례) matchFormat("20010101", "####/##/##") -> "2001/01/01"
	 *       matchFormat("12345678", "##/## : ##") -> "12/34 : 56"
	 * </pre>
	 * @param	str			원본문자열
	 * @param	format		결과 포맷형태('#'문자에 원본 문자가 위치, 그외 문자는 그대로 표시)
	 * @return 	포맷으로 변환된 문자열
	 */
	public static String matchFormat(String str, String format) {
		if(str == null || str.length() == 0 ) return str;
		int len = format.length();
		char[] result = new char[len];
		for(int i=0,j=0; i<len; i++,j++) {
			if(format.charAt(i)=='#') {
				try {
					result[i]= str.charAt(j);
				}catch(StringIndexOutOfBoundsException e) {
					result[i]= '\u0000';
				}
			} else {
				result[i]= format.charAt(i);
				j--;
			}
		}
		return new String(result);
	}

	public static boolean isCrackedHangleIndex(byte[] byteArr, int index) {
		boolean crashFlag = false;
		if (byteArr==null || byteArr.length==0 || byteArr.length<=index) return crashFlag;
		for (int i=index-1; i>=0; i--) {
			if (byteArr[i]>0) break;
			crashFlag = !crashFlag;
		}
		return crashFlag;
	}

	public static String toCurFormat(double arg) {
		return new DecimalFormat("###,##0").format(arg);
	}

	public static String getDirDelimiter(String path) {
		return path.indexOf("/") >=0? "/"  :  //unix
		       path.indexOf("\\")>=0? "\\" :  //windows
		       path.indexOf(".") >=0? "."  :  //host
		                              "/";    //default(unix)
	}

	public static String getRandomDigit(long digitLen) {
		if (digitLen <= 0) return "";

		String format = "";
		for (int i=0; i<digitLen; i++) format += "0";

		DecimalFormat df = new DecimalFormat(format);
		long randomDigit = (long) (Math.random() * Long.parseLong("1"+format));

		return df.format(randomDigit);
	}

	public static String concateString(String[] valueArray) {
		return concateString(valueArray, ",");
	}

	public static String concateString(String[] valueArray, String delimiter) {
		if (valueArray == null || valueArray.length == 0) return "";
		String concateStr = valueArray[0];
		for (int i=1; i<valueArray.length; i++) {
			concateStr += delimiter + valueArray[i];
		}
		return concateStr;
	}
	
    /**
     * 1. 기능 : 주어진 문자열에서 지정된 문자를 잘라낸다.
     * 2. 처리 개요 : 
     *     - 주어진 문자열에서 끝에서 부터 지정된 문자를 반복되는 만큼 잘라낸다.
     * 3. 주의사항
	 *
     * @param inStr - 입력 문자열
     * @param inChar - 잘라낼 문자
     * @return 결과문자열
     */
    public static String rtrimChar( String inStr, char inChar){
    	int len = inStr.getBytes().length;
    	byte newStr[]=null;
    	byte[]  val = inStr.getBytes();
    	
    	while ((0 < len) && (val[len -1] == inChar)) {
    	    len--;
    	}
    	if (len > 0 ){
    		newStr = new byte[len];
    		System.arraycopy( val,0,newStr,0,len);
    	}

    	return newStr == null ? null : new String(newStr);// 20250910 npe
    }

    /**
     * 1. 기능 : 주어진 문자열에서 지정된 문자를 잘라낸다.
     * 2. 처리 개요 : 
     *     - 주어진 문자열에서 끝에서 부터 지정된 문자를 반복되는 만큼 잘라낸다.
     * 3. 주의사항
	 *
     * @param inStr - 입력 문자열
     * @param inChar - 잘라낼 문자
     * @return 결과문자열
     */
    public static byte[] rtrimChar( byte[] buf, char inChar){
    	int len = buf.length;
    	
    	while ((0 < len) && ( (buf[len - 1] == inChar) || buf[len -1] == '\r' || buf[len -1] == '\n' )) {
    	    len--;
    	}
    	if ( len > 0 ){
        	byte[] newBuf = new byte[len];
        	System.arraycopy( buf, 0, newBuf, 0, len);
        	return newBuf;
    	} else {
        	return null;
    	}
    }
    
	/**
     * 1. 기능 : 주어진 스트링에 대해 offset 만큼의 byte 를 잘라내어 리턴한다.
     * 2. 처리 개요 : 
     *     - substring("1234",2) --> "34"
     * 3. 주의사항
	 *
     * @param    inStr 	 String Source
	 * @param    offset  offset
	 * @return   String
     */
    public static String substring( String inStr, int offset){
    	int len = inStr.getBytes().length - offset;
    	byte newStr[] =  new byte[len];
    	System.arraycopy( inStr.getBytes(), offset, newStr, 0, len);
    	return new String (newStr);
    }
    
	/**
     * 1. 기능 : 에러대신 Zero String을 리턴하는 substring method
     * 2. 처리 개요 : 
     *     - getSubstring("1234",4,2) --> ""
     * 3. 주의사항
	 *
     * @param    Str 	 String Source
	 * @param    start    start index.
	 * @param    len      length
	 * @return   String
     */
    public static String getSubstring(String Str, int start, int len)
    {
        if (Str == null) return "";
        int slen = Str.length();

        if ((slen < 1) || (start<0) || (len < 1)) return "";

        if ((slen-1) < start) return "";

        if (slen < (start+len)) {
        	return Str.substring(start,Str.length());
        }
        else {
        	return Str.substring(start,start+len);
        }
    }
    
	/**
     * 1. 기능 : 주어진 스트링에 대해 offset 만큼의 byte 를 잘라내어 리턴한다.
     * 2. 처리 개요 : 
     *     - substring("1234",2) --> "34"
     * 3. 주의사항
	 *
     * @param    inStr 	 String Source
	 * @param    offset  offset
	 * @return   String
     */
    public static byte[] split( byte[] str, int interval, byte[] del){
    	int offset1 = 0;
    	int offset2 = 0;
    	int len = str.length;
    	int delLen = del.length;
    	int newLen = len + ( ( ( ( len - 1)/interval ) + 1 )* delLen )  ;
    	byte[] newByte = new byte[newLen];
    	while ( offset1 < len - interval ){
    		System.arraycopy( str, offset1, newByte, offset2, interval);
    		offset1 += interval;
    		offset2 += interval;
    		System.arraycopy( del, 0, newByte, offset2, delLen);
    		offset2 += delLen;
    	}
    	System.arraycopy( str, offset1, newByte, offset2, len - offset1);
    	offset2 += len - offset1;
		System.arraycopy( del, 0, newByte, offset2, delLen);
    	
    	return newByte;
    }
    
//    public static String getCheckFileName( String realDirPath ){
//    	return realToRootDir( realDirPath );
//    	PropManager pmanager = PropManager.getInstance();
//    	String ext = ".chk";
//    	if ( realDirPath == null || realDirPath.equals(""))
//    		return realDirPath;
//    	try {
//    		String recvReal = BatchDirUtil.getResponseRealDir();
//    		ext = pmanager.getProperty("CBSDirInfo", "chk.ext");
//        	if (realDirPath.indexOf(recvReal) > -1 )
//        		return replaceStr( realDirPath, recvReal, BatchDirUtil.getResponseArchDir()) + ext;
//        	
//		} catch (Exception e) {}
//    	return realDirPath + ext ;
//    }
    
    public static String realToRootDir( String realDirPath ){
    	if ( realDirPath == null || realDirPath.equals(""))
    		return realDirPath;
    	try {
        	String recvReal = BatchDirUtil.getResponseRealDir();
        	if (realDirPath.indexOf(recvReal) > -1 )
        		return replaceStr( realDirPath, recvReal, BatchDirUtil.getResponseRootDir() );
		} catch (Exception e) {
	    	return null;
		}
    	return null;
    }

	
    public static String realToArchDir( String realDirPath ){
    	if ( realDirPath == null || realDirPath.equals(""))
    		return realDirPath;
    	try {
//        	String sendReal = BatchDirUtil.getRequestRealDir();
        	String recvReal = BatchDirUtil.getResponseRealDir();
//        	if ( realDirPath.indexOf(sendReal) > -1 )
//        		return replaceStr( realDirPath, sendReal, BatchDirUtil.getResponseArchDir() );
//        	else 
        	if (realDirPath.indexOf(recvReal) > -1 )
        		return replaceStr( realDirPath, recvReal, BatchDirUtil.getResponseArchDir() );
		} catch (Exception e) {
	    	return null;
		}
    	return null;
    }

//    public static String rootToArchDir( String rootDirPath ){
//    	if ( rootDirPath == null || rootDirPath.equals(""))
//    		return rootDirPath;
//    	try {
//        	String recvRoot = BatchDirUtil.getResponseRootDir();
//        	if ( rootDirPath.indexOf(recvRoot) > -1 )
//        		return replaceStr( rootDirPath, recvRoot, BatchDirUtil.getResponseArchDir() );
//		} catch (Exception e) {
//	    	return null;
//		}
//    	return rootDirPath;
//    }

//    public static String rootToNasDir( String rootDirPath ){
//    	if ( rootDirPath == null || rootDirPath.equals(""))
//    		return rootDirPath;
//    	try {
//        	String recvRoot = BatchDirUtil.getResponseRootDir();
//        	if ( rootDirPath.indexOf(recvRoot) > -1 )
//        		return replaceStr( rootDirPath, recvRoot, BatchDirUtil.getResponseNasDir() );
//		} catch (Exception e) {
//	    	return null;
//		}
//    	return rootDirPath;
//    }

//    public static String rootToChkDir( String rootDirPath ){
//    	if ( rootDirPath == null || rootDirPath.equals(""))
//    		return rootDirPath;
//    	try {
//        	String recvRoot = BatchDirUtil.getResponseRootDir();
//        	if ( rootDirPath.indexOf(recvRoot) > -1 )
//        		return replaceStr( rootDirPath, recvRoot, BatchDirUtil.getResponseChkDir() );
//		} catch (Exception e) {
//	    	return null;
//		}
//    	return rootDirPath;
//    }

    public static String realToErrorDir( String realDirPath ){
    	if ( realDirPath == null || realDirPath.equals(""))
    		return realDirPath;
    	try {
//        	String sendReal = BatchDirUtil.getRequestRealDir();
        	String recvReal = BatchDirUtil.getResponseRealDir();
//        	if ( realDirPath.indexOf(sendReal) > -1 )
//        		return replaceStr( realDirPath, sendReal, BatchDirUtil.getResponseErrorDir() );
//        	else 
        	if (realDirPath.indexOf(recvReal) > -1 )
        		return replaceStr( realDirPath, recvReal, BatchDirUtil.getResponseErrorDir() );
		} catch (Exception e) {
	    	return null;
		}
    	return null;
    }
    
    public static long getTotRecCountFromHeader( String header ){
    	long cnt = -1;
    	try {
			cnt = Long.parseLong(header.substring(27, 37));
		} catch (Exception e) {
//			e.printStackTrace();
		}
    	return cnt;
    }
    
    public static String getBaseDateFromHeader( String header ){
    	String baseDate = null;
    	try {
			baseDate = header.substring(19, 27); 
		} catch (Exception e) {
			baseDate = CalendarUtil.getCurrentTimeNoDash().substring(0,8);
		}
    	return baseDate;
    }

    public static String getDump(Throwable t) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        t.printStackTrace(pw);
        return sw.toString();
    }
   
	
}
