package seed.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.apache.log4j.Logger;
/*import org.hyperic.sigar.CpuPerc;
import org.hyperic.sigar.Mem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;*/
import org.jasypt.encryption.pbe.StandardPBEStringEncryptor;

public class SeedUtils {
	
	private static Logger log = Logger.getLogger(SeedUtils.class);
	
	private static MessageDigest md;
    static {
    	
        try{
            md = MessageDigest.getInstance("MD5");
        }catch(Exception e){
            md = null;
        }
    }
    
    private static byte[] md5(String source) {
        byte[] bytes = source.getBytes();
        byte[] digest = md.digest(bytes);
        return digest;
    }
	
	public static String getSeedMD5Code(String str){

		String MD5 = ""; 
		
		 try{
			 
			 MessageDigest md = MessageDigest.getInstance("MD5"); 
			 md.update(str.getBytes()); 
			 byte byteData[] = md.digest();
			 StringBuffer sb = new StringBuffer(); 
			 for(int i = 0 ; i < byteData.length ; i++){
				 sb.append(Integer.toString((byteData[i]&0xff) + 0x100, 16).substring(1));
			 }
			 MD5 = sb.toString();
		 }catch(NoSuchAlgorithmException e){
			 log.error("SeedUtils getSeedMD5Code Error");
			 MD5 = ""; 
		 }
		 
		 return MD5;
	}
	
	public static String getSeedSHA256Code(String str){

		String SHA256 = ""; 
		
		 try{
			 
			 MessageDigest md = MessageDigest.getInstance("SHA-256"); 
			 md.update(str.getBytes()); 
			 byte byteData[] = md.digest();
			 StringBuffer sb = new StringBuffer(); 
			 for(int i = 0 ; i < byteData.length ; i++){
				 sb.append(Integer.toString((byteData[i]&0xff) + 0x100, 16).substring(1));
			 }
			 SHA256 = sb.toString();
		 }catch(NoSuchAlgorithmException e){
			 log.error("SeedUtils getSeedSHA256Code Error");
			 SHA256 = ""; 
		 }
		 
		 return SHA256;
	}
	
    public static String getSeedEncrypt(String input, String key){
        byte[] ivbytes = "SeedSecretMd5ASE".getBytes();
        IvParameterSpec ips = new IvParameterSpec(ivbytes);
        byte[] keybytes = md5(key);
        byte[] crypted = null;
        
        try{
        	
        	SecretKeySpec skey = new SecretKeySpec(keybytes, "AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, skey, ips);
            byte[] ptext = input.getBytes();
            crypted = cipher.doFinal(ptext);
        }catch(NoSuchPaddingException e){
        	log.error("SeedUtils getSeedEncrypt NoSuchPaddingException");
        }catch(NoSuchAlgorithmException e){
        	log.error("SeedUtils getSeedEncrypt NoSuchAlgorithmException");
        }catch(InvalidKeyException e){
        	log.error("SeedUtils getSeedEncrypt InvalidKeyException");
        }catch(InvalidAlgorithmParameterException e){
        	log.error("SeedUtils getSeedEncrypt InvalidAlgorithmParameterException");
        }catch(IllegalBlockSizeException e){
        	log.error("SeedUtils getSeedEncrypt IllegalBlockSizeException");
        }catch(BadPaddingException e){
        	log.error("SeedUtils getSeedEncrypt BadPaddingException");
        }
        return new String(Hex.encodeHexString(crypted));
    }
    
    public static String getSeedDecrypt(String input, String key){
        IvParameterSpec ips = new IvParameterSpec("SeedSecretMd5ASE".getBytes());
        byte[] keybytes = md5(key);
        byte[] output = null;
        
        try{
        	
            SecretKeySpec skey = new SecretKeySpec(keybytes, "AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, skey, ips);
            output = cipher.doFinal(Hex.decodeHex(input.toCharArray()));
        }catch(NoSuchPaddingException e){
        	log.error("SeedUtils getSeedDecrypt NoSuchPaddingException");
        }catch(NoSuchAlgorithmException e){
        	log.error("SeedUtils getSeedDecrypt NoSuchAlgorithmException");
        }catch(InvalidKeyException e){
        	log.error("SeedUtils getSeedDecrypt InvalidKeyException");
        }catch(InvalidAlgorithmParameterException e){
        	log.error("SeedUtils getSeedDecrypt InvalidAlgorithmParameterException");
        }catch(IllegalBlockSizeException e){
        	log.error("SeedUtils getSeedDecrypt IllegalBlockSizeException");
        }catch(BadPaddingException e){
        	log.error("SeedUtils getSeedDecrypt BadPaddingException");
        }catch(DecoderException e){
        	log.error("SeedUtils getSeedDecrypt DecoderException");
        }
        return new String(output);
    }
    
    public static String getSeedKisaEncrypt(String input){
    	
    	String output = "";
		
    	try{
	        // 암복호화에 사용할 키 배열생성
	        int[] seedKeyByte = SeedKISA.getSeedRoundKey("SeedSecretKISARoundKey");
	
	        output = SeedKISA.getSeedEncrypt(input, seedKeyByte);
    	}catch (Exception e) {
        	log.error("SeedUtils getSeedKisaEncrypt Exception");
		}
    	
    	return output;
    }
    
    public static String getSeedKisaDecrypt(String input){
    	
    	String output = "";
		
    	try{
	        // 암복호화에 사용할 키 배열생성
	        int[] seedKeyByte = SeedKISA.getSeedRoundKey("SeedSecretKISARoundKey");
	
	        output = SeedKISA.getSeedDecrypt(input, seedKeyByte);
    	}catch (Exception e) {
        	log.error("SeedUtils getSeedKisaDecrypt Exception");
		}
    	
    	return output;
    }

    /**
     * 전달 받은 경로의 폴더를 생성하는 메소드 mkdirs를 호출함
     * -> 생성후 해당 폴더에 대한 권한 설정을 실행
     * 생성된 폴더 및 파일 객체를 위의 메소드로 권한 수정 작업 진행 
     * 요거 하면 계정에 따라서 권한이 없어서 문제 발생 될수 있음 
     * Was=서버파일관리 권한이 완전 동일 해야함
     * @param String dirPath 폴더 경로
     */
	/*public static void setSeedMkDirs(String dirPath){
		
		File file = new File(dirPath);
		
		if (file.exists() || file.isDirectory()){
			return;
		}
		
		if(!file.exists()){
			file.mkdirs();
		}
	}*/
	
    public static void setSeedMkDirs(String dirPath) {
        File file = new File(dirPath);
        if (!file.exists() && !file.isDirectory()) {
            if (!file.exists()) {
                file.mkdirs();
            }

        }
    }
	
	public static void setSeedFileCopy(String inFileName, String outFileName){
		
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		try{
			
			fis = new FileInputStream(inFileName);
			fos = new FileOutputStream(outFileName);
	
			byte[] buffer = new byte[(int)1024];
			
			int i = 0;
			
			if (fis != null && fos != null) {
				while ((i = fis.read(buffer)) != -1) {
					fos.write(buffer, 0, i);
				}
			}
			
			fis.close();
			fos.close();
	
		}catch (FileNotFoundException e){
			log.error(e);
		}catch (IOException e){
			log.error(e);
		}catch (Exception e){
			log.error(e);
		}finally{
			if(fis!=null){try{fis.close();}catch(IOException e){log.error("CHECK ERROR:",e);}}
			if(fos!=null){try{fos.close();}catch(IOException e){log.error("CHECK ERROR:",e);}}
		}
	}
	
	public static void setSeedMoveFile(String dirPath, String destPath){
		
		File orgFile = new File(dirPath);
		File destFile = new File(destPath);
		
		if(orgFile != null && orgFile.exists()){
			orgFile.renameTo(destFile);
		}
	}
	
	public synchronized static void setSeedDeleteFile(String dirPath){
		
		File file = new File(dirPath);
		
		if(file != null && file.exists()){
			file.delete();
		}
	}
	
	public synchronized static void setSeedDeleteFiles(String dirPath, String noFoloder) {
		
	    File file = new File(dirPath);
	    
		if (!file.exists() || !file.isDirectory()){
			return;
		}
		
	    String[] fnameList = file.list();
	    
	    if(fnameList != null && fnameList.length > 0){
	    	
		    int fCnt = fnameList.length;
		    String childPath = "";
		    
		    for(int i = 0; i < fCnt; i++) {
		    	childPath = dirPath+"/"+fnameList[i];
		    	File f = new File(childPath);
	  
				if(noFoloder != null && !noFoloder.equals("")){
					if(f.getName().equals(noFoloder)){
						continue;
					}
				}
				  
				if(f != null && !f.isDirectory()) {
					f.delete();   //파일이면 바로 삭제
				}else {
					setSeedDeleteFiles(childPath, noFoloder);
				}
		    }
	    }
	    
	    File f = new File(dirPath);
	    f.delete();
	}
	
	public static void setSeedCopyFiles(File sourcelocation , File targetdirectory, String[] noCopyFolders, String[] noCopyFiles) {
		
		//디렉토리인 경우
		if (sourcelocation.isDirectory()) {
			
			boolean chkNoFolder = false;
			
			for(int i=0; i<noCopyFolders.length; i++){
				if(sourcelocation.getName().indexOf(noCopyFolders[i]) > -1){
					chkNoFolder = true;
					break;
				}
			}
			
			if(!chkNoFolder){
				//복사될 Directory가 없으면 만듭니다.
				if (!targetdirectory.exists()) {
					targetdirectory.mkdir();
				}
	      
				String[] children = sourcelocation.list();
				
				if(children != null && children.length > 0){
					
					for (int i=0; i<children.length; i++) {
						setSeedCopyFiles(new File(sourcelocation, children[i]), new File(targetdirectory, children[i]), noCopyFolders, noCopyFiles);
					}
				}
			}
			
		} else {
			
			boolean chkNoFile = false;
			
			if(noCopyFiles != null && noCopyFiles.length > 0){
			
				for(int i=0; i<noCopyFiles.length; i++){
					
					if(sourcelocation.getName().indexOf(noCopyFiles[i]) > -1){
						chkNoFile = true;
						break;
					}
				}
			}
			
			if(!chkNoFile){
				
				//파일인 경우
				InputStream in = null;                
				OutputStream out = null;
				
				try{
					
					in = new FileInputStream(sourcelocation);                
					out = new FileOutputStream(targetdirectory);
					
					//Copy the bits from instream to outstream
					byte[] buf = new byte[1024];
					int len;
					while ((len = in.read(buf)) > 0) {
						out.write(buf, 0, len);
					}
					
					in.close();
					out.close();
					
				}catch (IOException e){
					log.error("IOException Error");
				}finally{
					if (in != null) {
						try{
							in.close();
						}catch (IOException e){
							log.error("IOException Error");
						}
					}
					
					if (out != null) {
						try{
							out.close();
						}catch (IOException e){
							log.error("IOException Error");
						}
					}
				}
			}
		}
	}	
	
	public static ArrayList<Map<String, Object>> getSeedDirFiles(String dirPath, String dirType) {
		
		ArrayList<Map<String, Object>> arrayList = new ArrayList<Map<String,Object>>();
		
		File file = new File(dirPath);
		
		if (!file.exists() || !file.isDirectory()){
			return null;
		}
		
	    String[] fnameList = file.list();
	    int fCnt = 0;
	    if(fnameList != null && fnameList.length > 0){
	    	fCnt = fnameList.length;
	    }
	    String childPath = "";
	    
	    for(int i = 0; i < fCnt; i++) {
			childPath = dirPath+"/"+fnameList[i];
			File f = new File(childPath);
			
			if(f != null){
				
				Map<String, Object> dirMap = new HashMap<String, Object>(); 
				
				if(dirType.equals("D") && f.isDirectory()){
					dirMap.put("dirName", f.getName());
					arrayList.add(dirMap);
				}else if(dirType.equals("F") && !f.isDirectory()){
					dirMap.put("fileName", f.getName());
					dirMap.put("fileSize", f.length());
					dirMap.put("fileSubType", f.getName().substring(f.getName().lastIndexOf(".")+1));
					arrayList.add(dirMap);
				}
			}
	    }
	    
	    return arrayList;
	}
	
	public static String getStandardPBEStringDecrypt(String strEncrypt){
		
		String strDecrypt = strEncrypt.substring(4, strEncrypt.length()-1);
		
		StandardPBEStringEncryptor pbeEnc = new StandardPBEStringEncryptor();
	    pbeEnc.setPassword("web"); // PBE 값(XML PASSWORD설정)
	    
	    return pbeEnc.decrypt(strDecrypt);
	}
	
	public static String setReplaceNull(Object strOriginal){
		
		if(strOriginal == null || strOriginal.equals("")){
			strOriginal = "";
		}
		
//		//주민번호 형태 인 경우 해당 *로 치환
//		strOriginal = strOriginal.toString().replaceAll("\\d{6}(|\\p{Z}|\\p{Z}\\p{Z})\\-(|\\p{Z}|\\p{Z}\\p{Z})[1-4]\\d{6}", "******-*******");
//		strOriginal = strOriginal.toString().replaceAll("\\d{6}(|\\p{Z}|\\p{Z}\\p{Z})\\~(|\\p{Z}|\\p{Z}\\p{Z})[1-4]\\d{6}", "******~*******");
//		
//		//휴대폰 번호 인 경우 해당 *로 치환
//		strOriginal = strOriginal.toString().replaceAll("^01(?:0|1|[6-9])(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})(?:\\d{3}|\\d{4}) - \\d{4}$", "***-****-****");
//		strOriginal = strOriginal.toString().replaceAll("^01(?:0|1|[6-9])(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})(?:\\d{3}|\\d{4}) ~ \\d{4}$", "***~****~****");
//		
//		//일반전화 번호, 팩스 번호 인 경우 해당 *로 치환
//		strOriginal = strOriginal.toString().replaceAll("^\\d{2,3}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{3,4}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}$", "***-****-****");
//		strOriginal = strOriginal.toString().replaceAll("^\\d{2,3}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{3,4}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}$", "***~****~****");
//		
//		//카드번호 인 경우 해당 *로 치환
//		strOriginal = strOriginal.toString().replaceAll("\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}", "****-****-****-****");
//		strOriginal = strOriginal.toString().replaceAll("\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}", "****~****~****~****");

		return strOriginal.toString();
	}
	
	public static String setReplaceNull(Object strOriginal, Object strReplace){
		
		if(strOriginal == null || strOriginal.equals("") || strOriginal.equals("null")){
			return strReplace.toString();
		}
		
		return strOriginal.toString();
	}
	
	public static void getZipFile(String path, String fileName) {
		
		File f = new File(path);  //파일이름미포함
		String files[] = f.list(); // f object 에 있는 파일목록

		String outFilename = path + "/" + fileName + ".zip";
		int number = 1;
		
		while (true) {
			File newFile = new File(outFilename);
			if (newFile != null && newFile.exists()) {
				outFilename = path + "/" + fileName + "_" + number + ".txt";
				number++;
			} else {
				break;
			}
		}

		int size = 1024;
		//Create a buffer for reading the files
		byte[] buf = new byte[size];

		//Create the ZIP file
		ZipOutputStream zos = null;
		FileInputStream fis = null;

		try{
			
			zos = new ZipOutputStream(new FileOutputStream(outFilename));
			
			//Compress the files
			if(files != null && files.length > 0){
				
				for (int i = 0; i < files.length; i++) {
					fis = new FileInputStream(path + "/" + files[i]);
	
					//Add ZIP entry to output stream.
					zos.putNextEntry(new ZipEntry(files[i])); // Zip 파일에 경로를 정하여 저장할수 있다.
					//Transfer bytes from the file to the ZIP file
	
					int len;
					while ((len = fis.read(buf, 0, size)) > 0) {
						zos.write(buf, 0, len);
					}
					
					//Complete the entry
					zos.closeEntry();
					fis.close();
				}
			}
			
			//Complete the ZIP file
			zos.close();
		}catch (FileNotFoundException e){
			log.error("FileNotFoundException Error");
		}catch (IOException e){
			log.error("IOException Error");
		}finally{
			if (fis != null) {
				try{
					fis.close();
				}catch (IOException e){
					log.error("IOException Error");
				}
			}
			
			if (zos != null) {
				try{
					zos.close();
				}catch (IOException e){
					log.error("IOException Error");
				}
			}
		}
	}

	 public static void setUnZipFile(String zipPath, String unzipPath) {
		 
		  File zipFile = new File(zipPath);   //파일이름포함
		  File targetDir = new File(unzipPath);  //미포함

		  FileInputStream fis = null;
		  ZipInputStream zis = null;
		  FileOutputStream fos = null;

		  try{
			  
			  fis = new FileInputStream(zipFile);
			  zis = new ZipInputStream(fis); // ZipInputStream
			  
			  ZipEntry zentry = null;

			  while ((zentry = zis.getNextEntry()) != null) {
				  String fileNameToUnzip = zentry.getName();
				  File targetFile = new File(targetDir, fileNameToUnzip);

				  if (zentry.isDirectory()) {// Directory 인 경우
					  File newDir = new File(targetFile.getAbsolutePath());
					  newDir.mkdirs();
				  } else { // File 인 경우
					  //parent Directory 생성
					  File newFile = new File(targetFile.getParent());
					  newFile.mkdirs();
					  
					  fos = new FileOutputStream(targetFile);
					  byte[] buffer = new byte[1024];
					  int len = 0;
					  
					  while ((len = zis.read(buffer)) != -1) {
						  fos.write(buffer, 0, len);
					  }
					  fos.close();
				  }
			  }
			  
			  zis.close();
			  fis.close();
			  
		  }catch (FileNotFoundException e){
			  log.error("FileNotFoundException Error");
		  }catch (IOException e){
			  log.error("IOException Error");
		  }finally{
			  
			  if (fos != null) {
				  try{
					  fos.close();
				  }catch (IOException e){
					  log.error("IOException Error");
				  }
			  }
			  
			  if (zis != null) {
				  try{
					  zis.close();
				  }catch (IOException e){
					  log.error("IOException Error");
				  }
			  }
			  
			  if (fis != null) {
				  try{
					  fis.close();
				  }catch (IOException e){
					  log.error("IOException Error");
				  }
			  }
		  }
	 }
	 
	public static String getRandomData (int length) {
		int index = 0;
		char[] charSet = new char[] {
			    '0','1','2','3','4','5','6','7','8','9'
				,'A','B','C','D','E','F','G','H','I','J','K','L','M'
				,'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'
				,'a','b','c','d','e','f','g','h','i','j','k','l','m'
				,'n','o','p','q','r','s','t','u','v','w','x','y','z'};
		
		StringBuffer sb = new StringBuffer();
		for (int i=0; i<length; i++) {
			index =  getRandom(62,0);
			if(index > 0){
				sb.append(charSet[index]);
			}
		}
		
		return sb.toString();
	}
	
	/**
	 * random한 값을 얻고자 할때 사용하는 메소드
	 * 보안 관련 체크를 위해서 Math.random 이 아닌 SecureRandom을 이용해서 작업을 진행함
	 * 결과 값이 min값보다 작은경우 rendom함수 재호출 해서 값을 넘겨주는 방식
	 * @param int max 난수 최대값
	 * @param int min 난수 최소값
	 * @return int 난수값
	 * */
	public static int getRandom(int max, int min){
		int result = 0;
		SecureRandom ran = new SecureRandom();
		result = ran.nextInt(max);
		return result < min ? getRandom(max,min) : result;
	}
	
	public static String getSeedWE8DECtoKor(String strData){
		
		//ex.) UTL_RAW.CAST_TO_RAW(columnName)
		
		if (strData.length() % 2 != 0) {
			return "";
		}
		
		StringBuffer buff = new StringBuffer();
		
		int i = 0;
		
		while( i < strData.length() ){
			buff.append((char)Integer.parseInt(strData.substring(i, i+2),16));
			i = i + 2;
		}
		
		try{
			
			if(buff.toString() != null){
				return new String(buff.toString().getBytes("8859_1"), "EUC_KR");
			}else{
				return buff.toString();
			}
			
		 }catch(Exception ex){
			  return ex.toString();
		 }
	}
	
	public static String setTagRemove(String strOriginal){
		
		String strRemove = "";
		
		if(strOriginal != null && !"".equals(strOriginal)){
			strRemove = strOriginal.replaceAll("<(/)?([a-zA-Z]*)(\\s[a-zA-Z]*=[^>]*)?(\\s)*(/)?>", "");
		}
		
		return strRemove;
	}
	
	public static boolean setChkFilePath(String filePath){
		
		boolean chk = false;
		
		if(filePath != null && !"".equals(filePath)){
			if(filePath.indexOf(".") >= 0){
				chk = true;
			}
		}
		
		return chk;
	}
	
	public static Long getFolderSize(File file, Long volume){
		
		File[] listFile = file.listFiles();
		
		if(listFile != null && listFile.length > 0){
	
			for(int i=0;i<listFile.length;i++){
				if(listFile[i].isFile()){
					volume += listFile[i].length();
				}else{
					volume = getFolderSize(listFile[i], volume);
				}
			}
		}
		
		return volume;
	}
	
	public static void getMemory(){
		
		Runtime runtime = Runtime.getRuntime();
		
		DecimalFormat format = new DecimalFormat("###,###,###.##");
		
		long max = runtime.maxMemory();
		
		long total = runtime.totalMemory();
		
		long free = runtime.freeMemory();
		
		log.error("=============================================");
		log.error("=============================================");
		
		log.error("Max : " + format.format(max));
		log.error("Total : " + format.format(total));
		log.error("Free : " + format.format(free));
	}

	 /**
	 * 행안부 보안취약점 점검 조치 방안.
	 *
	 * @param value
	 * @return
	 */
 	public static String setFilePathReplaceAll(String value) {
 		
 		String returnValue = value;
 		
 		if (returnValue == null || returnValue.trim().equals("")) {
 			return "";
 		}

 		returnValue = returnValue.replaceAll("[.][.]/", "");
 		returnValue = returnValue.replaceAll("[.]/", "");
 		returnValue = returnValue.replaceAll("[.]\\\\\\\\", "");
 		returnValue = returnValue.replaceAll("[.][.]\\\\\\\\", "");
 		returnValue = returnValue.replaceAll("\\\\\\\\", "");
 		returnValue = returnValue.replaceAll("\\\\[.]\\\\[.]", ""); // ..
 		returnValue = returnValue.replaceAll("&", "");

 		return returnValue;
 	}
 	
	public static String replaceXss(String s){
		
		if(s != null && !"".equals(s)){
			s = s
			.replaceAll("(?i)script", "s-c-r-i-p-t")
			.replaceAll("(?i)javascript", "j-v-a-s-c-r-i-p-t")
			.replaceAll("(?i)expression", "e-x-p-r-e-s-s-i-o-n")
			.replaceAll("(?i)vbscript", "v-b-s-c-r-i-p-t")
			.replaceAll("(?i)onabort", "0nabort")
			.replaceAll("(?i)onactivate", "0nactivate")
			.replaceAll("(?i)onafter", "0nafter")
			.replaceAll("(?i)onbefore", "0nbefore")
			.replaceAll("(?i)onblur", "0nblur")
			.replaceAll("(?i)onbounce", "0nbounce")
			.replaceAll("(?i)oncellchange", "0ncellchange")
			.replaceAll("(?i)onchange", "0nchange")
			.replaceAll("(?i)onclick", "0nclick")
			.replaceAll("(?i)oncontextmenu", "0ncontextmenu")
			.replaceAll("(?i)oncontrolselect", "0ncontrolselect")
			.replaceAll("(?i)oncopy", "0ncopy")
			.replaceAll("(?i)oncut", "0ncut")
			.replaceAll("(?i)ondataavailable", "0ndataavailable")
			.replaceAll("(?i)ondataset", "0ndataset")
			.replaceAll("(?i)ondblclick", "0ndblclick")
			.replaceAll("(?i)ondeactivate", "0ndeactivate")
			.replaceAll("(?i)ondrag", "0ndrag")
			.replaceAll("(?i)ondrop", "0ndrop")
			.replaceAll("(?i)onerror", "0nerror")
			.replaceAll("(?i)onfilterchange", "0nfilterchange")
			.replaceAll("(?i)onfinish", "0nfinish")
			.replaceAll("(?i)onfocus", "0nfocus")
			.replaceAll("(?i)onhelp", "0nhelp")
			.replaceAll("(?i)onkeydown", "0nkeydown")
			.replaceAll("(?i)onkeypress", "0nkeypress")
			.replaceAll("(?i)onkeyup", "0nkeyup")
			.replaceAll("(?i)onload", "0nload")
			.replaceAll("(?i)onlosecapture", "0nlosecapture")
			.replaceAll("(?i)onmouse", "0nmouse")
			.replaceAll("(?i)onmove", "0nmove")
			.replaceAll("(?i)onpaste", "0npaste")
			.replaceAll("(?i)onpropertychange", "0npropertychange")
			.replaceAll("(?i)onreadystatechange", "0nreadystatechange")
			.replaceAll("(?i)onreset", "0nreset")
			.replaceAll("(?i)onresize", "0nresize")
			.replaceAll("(?i)onrow", "0nrow")
			.replaceAll("(?i)onscroll", "0nscroll")
			.replaceAll("(?i)onselect", "0nselect")
			.replaceAll("(?i)onselectionchange", "0nselectionchange")
			.replaceAll("(?i)onselectstart", "0nselectstart")
			.replaceAll("(?i)onstart", "0nstart")
			.replaceAll("(?i)onstop", "0nstop")
			.replaceAll("(?i)onsubmit", "0nsubmit")
			.replaceAll("(?i)onunload", "0nunload");
		}
		
		return s;
	}
 	
	public static String fileSizeConvert(String fileSize, String convertUnit){
		String unitStr 				= "Mbyte";
		long longFileSize 			= Long.parseLong(fileSize);
		double doubleFileSize 	= (double)longFileSize;
		
		doubleFileSize = doubleFileSize/1024/1024;
		
		DecimalFormat df = new DecimalFormat("#,##0.00");
		
		return df.format(doubleFileSize)+unitStr;
	}
	
	/**
	 * 정규식을 이용해서 넘겨받은 숫자형 String데이터를 3자리마다 ,를 찍어주는 메소드
	 * @param String objectData 변경할 데이터
	 * @return String 변경된 데이터
	 * */
	public static String stringDecimalWork(String objectData){
		if(objectData!=null){
			return objectData.replaceAll("(?<=[0-9])(?=([0-9][0-9][0-9])+(?![0-9]))", ",");
		}else{
			return "";
		}
	}
	
	public static String getByteCut(String str, int length, int chkLen){
		
		String returnStr = "";
		
		if(str != null && !str.equals("")){
			int iLoop = str.length();
			
			if(iLoop > length){
				int chkLoop = 0;
				for(int i=0; i<iLoop; i++){
					if(chkLoop >= length){
						returnStr = returnStr + "...";
						break;
					}
					char ch = str.charAt(i);
					Character.UnicodeBlock unicodeBlock = Character.UnicodeBlock.of(ch);
					if(Character.UnicodeBlock.HANGUL_SYLLABLES.equals(unicodeBlock) || 
							Character.UnicodeBlock.HANGUL_JAMO.equals(unicodeBlock) ||
							Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO.equals(unicodeBlock)){
						returnStr = returnStr+String.valueOf(ch);
						chkLoop = chkLoop+chkLen;
					}else{
						returnStr = returnStr+String.valueOf(ch);
						chkLoop = chkLoop+1;
					}
				}
			}else{
				returnStr = str;
			}
		}
		
		return returnStr;
	}
	
	public static String getJspContentTypeStr(){
		return "<%@ page language=\"java\" contentType=\"text/html; charset=UTF-8\" pageEncoding=\"UTF-8\"%>";
	}
	
	public static void setFileMkdirAuthSet(File dir){
		if(dir != null){
			dir.setExecutable(false, true);
			dir.setReadable(true);
			dir.setWritable(true, true);
		}
	}
	
	public static boolean getBrowserHtml5(String userAgent){
		
		boolean success = true;
		
		//IE 버전일때 체크
		if(userAgent.indexOf("msie") > -1 || userAgent.indexOf("trident/") > -1){
			
			//IE6, IE7은 Trident 없음
			if(userAgent.indexOf("trident/") <= -1){
				success = false;
			}else{
				if(userAgent.indexOf("trident/5.0") > -1){
					//IE 9
					success = false;
				}else if(userAgent.indexOf("trident/4.0") > -1){
					//IE 8
					success = false;
				}
			}
		}
		
		return success;
	}
	
	public static boolean getBrowserIE(String userAgent){
		
		boolean success = false;
		
		//IE 버전일때 체크
		if(userAgent.indexOf("msie") > -1 || userAgent.indexOf("trident/") > -1){
			success = true;
		}
		
		return success;
	}
	
	/**
	 * long형태의 데이터를 int형태로 변경하는 메소드
	 * 변경 실패시 IllegalArgumentException 발생
	 * */
	public static int safeLongToInt(long l) {
	    int i = (int)l;
	    if ((long)i != l) {
	        throw new IllegalArgumentException(l + " safeLongToInt에서 에러 발생");
	    }
	    return i;
	}
	
	public static boolean isMobile(String userAgent){
		boolean isMobile = false;
		userAgent 			= userAgent.toLowerCase();
		
		String[] mobileKeyWord = {"iphone","ipod","android","blackberry","opera mini","opera mobi","skyfire","maemo","windows phone","palm","iemobile","symbian","symbianos","fennec"};
		for(int i=0; i<mobileKeyWord.length; i++){
			String chkKeyWord = mobileKeyWord[i];
			if(userAgent.indexOf(chkKeyWord)>-1){
				isMobile = true;
				break;
			}
		}
		return isMobile;
	}
	
	public static boolean isTablet(String userAgent){
		boolean isTablet = false;
		userAgent 			= userAgent.toLowerCase();
		String[] mobileKeyWord = {"ipad","android 3","sch-i800","playbook","tablet","kindle","gt-p1000","sgh-t849","shw-m180s","a510","a511","a100","dell streak","silk"};
		for(int i=0; i<mobileKeyWord.length; i++){
			String chkKeyWord = mobileKeyWord[i];
			if(userAgent.indexOf(chkKeyWord)>-1){
				isTablet = true;
				break;
			}
		}
		return isTablet;
	}
	
	public static String encodeURIComponent(String s) {
	    String result = null;
	    try{
	      result = URLEncoder.encode(s, "UTF-8")
	                         .replaceAll("\\+", "%20")
	                         .replaceAll("\\%21", "!")
	                         .replaceAll("\\%27", "'")
	                         .replaceAll("\\%28", "(")
	                         .replaceAll("\\%29", ")")
	                         .replaceAll("\\%7E", "~");
	    }catch (UnsupportedEncodingException e){result = s;}
	    return result;
	}

	public static boolean isCookieChk(String cookieKey, int cookieHour, HttpServletRequest request, HttpServletResponse response){
		
		try {
			
			if(cookieHour == 0){
				return true;
			}
			
			SeedCookieUtil seedCookieUtil = new SeedCookieUtil();
			
			String cookieVal = seedCookieUtil.getCookie(request, cookieKey);

			if (!("Y".equals(cookieVal))) {
				seedCookieUtil.setCookie(response, cookieHour * 24 * 60 * 60, "/", cookieKey, "Y", true);
				return true;
			}
			
		}catch (Exception localException){
			log.error("Exception localException");
		}
		
		return false;
	}
	
/*	public static String getCpuInfo() {
		
		String cpuInfo = "";
		
		Sigar sigar = new Sigar();

        CpuPerc cpu;
        
		try {
			cpu = sigar.getCpuPerc();
			cpuInfo = CpuPerc.format(cpu.getUser());
		} catch (SigarException e) {
			log.error("CHECK ERROR:",e);
		}

        return cpuInfo;
   }
	
	public static String getMemoryInfo() {
		
		String memoryInfo = "";
		
		Sigar sigar = new Sigar();
        
        Mem mem;
		try {
			mem = sigar.getMem();
			memoryInfo = format(mem.getTotal()) + ":" + format(mem.getUsed()) + ":" + format(mem.getFree());
		} catch (SigarException e) {
			log.error("CHECK ERROR:",e);
		}
      
        return memoryInfo;
	}*/
	
	public static String format(Long value) {
    	return Long.toString(new Long(value / 1024));
    }
}