/*
 *  StringUtils.java
 * 
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *  
 *  Author: Winter Lau
 *  http://dlog4j.sourceforge.net
 *  
 */
package com.liusoft.dlog4j.upgrade;

import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

public class StringUtils extends org.apache.commons.lang.StringUtils{

	/**
	 * 如果系統中存在舊版本的數據，則此值不能修改，否則在進行密碼解析的時候出錯
	 */
    private static final String PASSWORD_CRYPT_KEY = "__jDlog_";
	private final static String DES = "DES";
	
	/**
	 * 判斷是不是一個合法的電子郵件地址
	 * @param email
	 * @return
	 */
	public static boolean isEmail(String email){
		if(email==null)
			return false;
		email = email.trim();
		if(email.indexOf(' ')!=-1)
			return false;
		
		int idx = email.indexOf('@');
		if(idx==0 || (idx+1)==email.length())
			return false;
		if(email.indexOf('@', idx+1)!=-1)
			return false;
		return true;
		/*
		Pattern emailer;
		if(emailer==null){
			String check = "^([a-z0-9A-Z]+[-|\\._]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
			emailer = Pattern.compile(check);
		}
	    Matcher matcher = emailer.matcher(email);
	    return matcher.matches();
		*/
	}
	/**
	 * 加密
	 * @param src 數據源
	 * @param key 密鑰，長度必須是8的倍數
	 * @return	  返回加密后的數據
	 * @throws Exception
	 */
	public static byte[] encrypt(byte[] src, byte[] key)
		throws Exception {
		//		DES算法要求有一個可信任的隨機數源
		SecureRandom sr = new SecureRandom();
		// 從原始密匙數據創建DESKeySpec對象
		DESKeySpec dks = new DESKeySpec(key);
		// 創建一個密匙工廠，然后用它把DESKeySpec轉換成
		// 一個SecretKey對象
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
		SecretKey securekey = keyFactory.generateSecret(dks);
		// Cipher對象實際完成加密操作
		Cipher cipher = Cipher.getInstance(DES);
		// 用密匙初始化Cipher對象
		cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
		// 現在，獲取數據并加密
		// 正式執行加密操作
		return cipher.doFinal(src);
	}
	
	/**
	 * 解密
	 * @param src	數據源
	 * @param key	密鑰，長度必須是8的倍數
	 * @return		返回解密后的原始數據
	 * @throws Exception
	 */
	public static byte[] decrypt(byte[] src, byte[] key)
		throws Exception {
		//		DES算法要求有一個可信任的隨機數源
		SecureRandom sr = new SecureRandom();
		// 從原始密匙數據創建一個DESKeySpec對象
		DESKeySpec dks = new DESKeySpec(key);
		// 創建一個密匙工廠，然后用它把DESKeySpec對象轉換成
		// 一個SecretKey對象
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
		SecretKey securekey = keyFactory.generateSecret(dks);
		// Cipher對象實際完成解密操作
		Cipher cipher = Cipher.getInstance(DES);
		// 用密匙初始化Cipher對象
		cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
		// 現在，獲取數據并解密
		// 正式執行解密操作
		return cipher.doFinal(src);
	}
    /**
     * 密碼解密
     * @param data
     * @return
     * @throws Exception
     */
    public final static String decrypt(String data){
        try {
            return new String(decrypt(hex2byte(data.getBytes()),PASSWORD_CRYPT_KEY.getBytes()));
        }catch(Exception e) {
        }
        return null;
    }
    /**
     * 密碼加密
     * @param password
     * @return
     * @throws Exception
     */
    public final static String encrypt(String password){
        try {
            return byte2hex(encrypt(password.getBytes(),PASSWORD_CRYPT_KEY.getBytes()));
        }catch(Exception e) {
        }
        return null;
    }
	/**
	 * 二行制轉字符串
	 * @param b
	 * @return
	 */
    public static String byte2hex(byte[] b) {
		String hs = "";
		String stmp = "";
		for (int n = 0; n < b.length; n++) {
			stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
			if (stmp.length() == 1)
				hs = hs + "0" + stmp;
			else
				hs = hs + stmp;
		}
		return hs.toUpperCase();
	}
    
    public static byte[] hex2byte(byte[] b) {
        if((b.length%2)!=0)
            throw new IllegalArgumentException("長度不是偶數");
		byte[] b2 = new byte[b.length/2];
		for (int n = 0; n < b.length; n+=2) {
		    String item = new String(b,n,2);
		    b2[n/2] = (byte)Integer.parseInt(item,16);
		}
        return b2;
    }
    
    /**
     * 大小寫無關的字符串替換策略
     * @param str
     * @param src
     * @param obj
     * @return
     */
    public static String replaceIgnoreCase(String str, String src, String obj){
    	String l_str = str.toLowerCase();
    	String l_src = src.toLowerCase();
    	int fromIdx = 0;
    	StringBuffer result = new StringBuffer();
    	do{
    		int idx = l_str.indexOf(l_src, fromIdx);
    		if(idx==-1)
    			break;
    		result.append(str.substring(fromIdx, idx));
    		result.append(obj);
    		fromIdx = idx + src.length();
    	}while(true);
    	result.append(str.substring(fromIdx));
    	return result.toString();
    }
	
    public static void main(String[] args) {
        String pwd = decrypt("B5947D180FF18B990EB65C9107FBC8FB");
        System.out.println("pwd="+pwd);
        
    }
}