package com.supServer.common.utils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * <pre>
 * <b>对象简化操作工具.</b>
 * <b>Description:</b> 
 *    
 * <b>Author:</b> zhaowei
 * <b>Date:</b> 2015-9-2 下午04:56:33
 * </pre>
 */
public class ObjUtil {

	/**
 	 * 把字符串转换为整数，如果转换失败，则返回NULL
 	 * @param numStr
 	 * @return 字符串对应的整数
 	 */
 	public static Integer toInt(Object numStr) {
 		if (null == numStr) {
 			return null;
 		}
 		Integer n = null;
 		try {
 			n = Integer.parseInt(numStr.toString());
 		} catch (NumberFormatException nfe) {
 			return null;
 		}
 		return n;
 	}
	/**
 	 * 把字符串转换为整数，如果转换失败，则返回0
 	 * @param numStr
 	 * @return 字符串对应的整数
 	 */
 	public static int toint(Object numStr) {
 		if (null == numStr) {
 			return 0;
 		}
 		int n = 0;
 		try {
 			n = Integer.parseInt(numStr.toString());
 		} catch (NumberFormatException nfe) {
 			return 0;
 		}
 		return n;
 	}
	/**
 	 * 把字符串转换为长整数，如果转换失败，则返回NULL
 	 * @param numStr
 	 * @return 字符串对应的整数
 	 */
 	public static Long toLong(Object numStr) {
 		if (null == numStr) {
 			return null;
 		}
 		Long n = null;
 		try {
 			n = Long.parseLong(numStr.toString());
 		} catch (NumberFormatException nfe) {
 			return null;
 		}
 		return n;
 	}
	/**
 	 * 把字符串转换为长整数，如果转换失败，则返回0l
 	 * @param numStr
 	 * @return 字符串对应的整数
 	 */
 	public static long tolong(Object numStr) {
 		if (null == numStr) {
 			return 0l;
 		}
 		long n = 0l;
 		try {
 			n = Long.parseLong(numStr.toString());
 		} catch (NumberFormatException nfe) {
 			return 0l;
 		}
 		return n;
 	}
	/**
 	 * 转换为浮点数，如果转换失败，则返回NULL
 	 * @param numStr
 	 */
 	public static Double toDouble(Object numStr) {
 		if (null == numStr) {
 			return null;
 		}
 		Double n = null;
 		try {
 			n = Double.parseDouble(numStr.toString());
 		} catch (NumberFormatException nfe) {
 			return null;
 		}
 		return n;
 	}
	/**
 	 * 转换为浮点数，如果转换失败，则返回NULL
 	 * @param numStr
 	 */
 	public static double todouble(Object numStr) {
 		if (null == numStr) {
 			return 0;
 		}
 		double n = 0;
 		try {
 			n = Double.parseDouble(numStr.toString());
 		} catch (NumberFormatException nfe) {
 			return 0;
 		}
 		return n;
 	}
    /**
     * 将对象转换成boolean类型;<br/> 当null==obj, 则直接返回 false.
     * 
     * @param obj 对象实例.
     * @return boolean类型值.
     */
    public static boolean tobool(Object obj) {
        return toBool(obj, false);
    }
    /**
     * 将对象转换成Boolean类型;<br/> 当null==obj, 则直接返回 null.
     * 
     * @param obj 对象实例.
     * @return Boolean类型值.
     */
    public static Boolean toBool(Object obj) {
        return toBool(obj, null);
    }
    /**
     * 将对象转换成Boolean类型;<br/> 当null==obj, 则直接返回 _default.
     * 
     * @param obj 对象实例.
     * @param _default 缺省值.
     * @return Boolean类型值.
     */
    public static Boolean toBool(Object obj, Boolean _default) {
        if (null == obj) {
            return _default;
        }
        String val = String.valueOf(obj);
        return ("true".equalsIgnoreCase(val) 
        		|| "yes".equalsIgnoreCase(val) 
        		|| (null != toDouble(val) && 0 < toDouble(val)));
    }
	/**
	 * 集合对象转字符串
	 * @param obj 需转对象
	 * @return 字符串表示
	 */
	public static String toStrFromArr(Object obj){
		if (obj == null) {
			return null;
		}
		StringBuffer sb = new StringBuffer();
		if(obj instanceof Object[]){
			if(((Object[]) obj).length <= 0){
				return null;
			}
			for(Object o : (Object[]) obj){
				sb.append(toStr(o)).append(",");
			}
			return sb.substring(0, sb.length() - 1);
		} else if (obj instanceof Collection){
			if(((Collection) obj).isEmpty()){
				return null;
			}
			for(Object o : (Collection) obj){
				sb.append(toStr(o)).append(",");
			}
			return sb.substring(0, sb.length() - 1);
		}
		return toStr(obj);
	}
	/**
	 * 对象转字符串
	 * @param obj 需转对象
	 * @return 字符串表示
	 */
	public static String toStr(Object obj){
		if (obj == null) {
			return null;
		}
		return obj.toString();
	}
	/**
	 * 对象转字符串
	 * @param obj 需转对象
	 * @param nulval 空值默认值，包括字符串“”空
	 * @return 字符串表示
	 */
	public static String toStr(Object obj, String defaultNulVal){
		String s = null;
		if (obj == null || "".equals(s = obj.toString())) {
			return defaultNulVal;
		}
		return s;
	}
	/**
	 * 对象转字符串, null时转换为""
	 * @param obj 需转对象
	 * @return 字符串表示
	 */
	public static String toStrNoNull(Object obj){
		if (obj == null) {
			return "";
		}
		return obj.toString();
	}
	
	/**
	 * 判断对象是否为空或空字符
	 * @param obj
	 * @return
	 */
	public static boolean isNul(Object obj) {
		if (obj == null || "".equals(obj) || "null".equals(obj) || 
				"undefined".equals(obj) || "".equals(obj.toString().trim())) {
			return true;
		}
		return false;
	}
	/**
	 * 判断数字是否为空，或者为0
	 * @param obj
	 * @return
	 */
	public static boolean isNulNumber(Object obj) {
		if (obj == null || "".equals(obj) || "null".equals(obj) || 
				"undefined".equals(obj) || "".equals(obj.toString().trim()) ||
				0 == ObjUtil.tolong(obj) || 0 == ObjUtil.todouble(obj)) {
			return true;
		}
		return false;
	}
	/**
	 * 判断对象是否为空或空字符或空集合
	 * @param obj
	 * @return
	 */
	public static boolean isNulOrEmpty(Object obj) {  
        if (obj == null)  
            return true;  
  
        if (obj instanceof CharSequence)  
            return ((CharSequence) obj).length() == 0;  
  
        if (obj instanceof Collection)  
            return ((Collection) obj).isEmpty();  
  
        if (obj instanceof Map)  
            return ((Map) obj).isEmpty();  
  
        if (obj instanceof Object[]) {  
            Object[] object = (Object[]) obj;  
            if (object.length == 0) {  
                return true;  
            }  
            boolean empty = true;  
            for (int i = 0; i < object.length; i++) {  
                if (!isNulOrEmpty(object[i])) {  
                    empty = false;  
                    break;  
                }  
            }  
            return empty;  
        }  
        return false;  
    }  
	
	/**
	 * 是否所有参数都为空，有一个不为空则false
	 * @param obj
	 * @return
	 */
	public static boolean allAreNul(Object... obj) {
		if(obj == null) return true;
		for(Object o : obj){
			if(!isNul(o)){
				return false;
			}
		}
		return true;
	}
	/**
	 * 是否所有参数都不为空，有一个为空则false
	 * @param obj
	 * @return
	 */
	public static boolean allNotNul(Object... obj) {
		if(obj == null) return false;
		for(Object o : obj){
			if(isNul(o)){
				return false;
			}
		}
		return true;
	}
	
	/**
	 * 查询一个字符串在目标字符串中出现次数（可覆盖计算）
	 * 如：",60,60,"中包含",60,"共2个
	 * @param src 目标字符串
	 * @param str 字符串
	 * @return
	 */
	public static int countMatchRide(String src, String str) {
		int total = 0;
		for (String tmp = src; tmp != null && tmp.length() >= str.length(); ){
			if (tmp.indexOf(str) == 0) {
				total ++;
			}
			tmp = tmp.substring(1);
		}
		return total;
	}
	
	/**
	 * 查询一个字符串在目标字符串中出现次数（不可覆盖计算）
	 * 如：",60,60,"中包含",60,"只算1个
	 * @param src 目标字符串
	 * @param str 字符串
	 * @return
	 */
	public static int countMatchNoRide(String src, String str) {
		int total = 0;
		for (String tmp = src; tmp != null && tmp.length() >= str.length(); ){
			if(tmp.indexOf(str) == 0){
				total ++;
				tmp = tmp.substring(str.length());
			} else {
				tmp = tmp.substring(1);
			}
		}
		return total;
	}
	
	/**
 	 * 把ID字符串转换成为整型列表
 	 * @param idsStr ID字符串，如 123,223,344  222###444###666
 	 * @param sepStr ID分隔符，如 ,  ####
 	 * @return ID的整型列表
 	 */
 	public static List<Integer> strIds2IntList(String idsStr, String sepStr){
 		if ( isNul(idsStr) || isNul(sepStr)) {
 			return null;
 		}
		List<Integer> idList = new ArrayList<Integer>();
		String[] idArr = idsStr.split(sepStr);
		for (String id : idArr) {
			if (!isNul(id)) {
				Integer iId = toInt(id.trim());
				if (null != iId) {
					idList.add(iId);
				}
			}
		}
		return (idList.size() > 0) ? idList : null;
 	}
	/**
 	 * 把ID字符串转换成为长整型列表
 	 * @param idsStr ID字符串，如 123,223,344  222###444###666
 	 * @param sepStr ID分隔符，如 ,  ####
 	 * @return ID的整型列表
 	 */
 	public static List<Long> strIds2LongList(String idsStr, String sepStr){
 		if ( isNul(idsStr) || isNul(sepStr)) {
 			return null;
 		}
		List<Long> idList = new ArrayList<Long>();
		String[] idArr = idsStr.split(sepStr);
		for (String id : idArr) {
			if (!isNul(id)) {
				Long iId = toLong(id.trim());
				if (null != iId) {
					idList.add(iId);
				}
			}
		}
		return (idList.size() > 0) ? idList : null;
 	}
 	/**
 	 * 把字符串块转换成为字符串列表
 	 * @param strs	字符串块，如 abc,xyz,opr  abc###xyz###opr
 	 * @param sep	分隔符， 如  ,  ####
 	 * @return 字符串列表
 	 */
 	public static List<String> strs2StrList(String strs, String sep){
 		if( isNul(strs) || isNul(sep) ){
 			return null;
 		}
		List<String> strList = new ArrayList<String>();
		
		String[] strArr = strs.split(sep);
		for(String str : strArr){
			if(!isNul(str)) {
				strList.add(str.trim());
			}
		}
		return (strList.size() > 0) ? strList : null;
 	}
 	
 	/**
 	 * 将List<Integer> 转化为 List<String>,并在每项前+前缀
 	 * @param list
 	 * @param prev
 	 * @return
 	 */
 	public static List<String> longList2StrListPrev(List<Long> list, String prev){
 		if( list == null ){
 			return null;
 		}
 		if( list.isEmpty() ){
 			return new ArrayList<String>();
 		}
 		prev = isNul(prev) ? "" : prev;
 		List<String> result = new ArrayList<String>();
 		for(Long i : list){
 			String istr = (i == null ? "" : prev + i);
 			result.add(istr);
 		}
 		return result;
 	}
 	
 	public static void main(String[] args){
// 		String[] str = new String[]{"qqq","errr","121","qsw"};
// 		List<String> arr = new ArrayList<String>();
// 		arr.add("zxxz1");
// 		arr.add("zxxz2");
// 		arr.add("zxxz3");
// 		
// 		System.out.println(toStrFromArr("qq"));
// 		System.out.println(toStrFromArr(arr));
 		
 		System.out.println( ObjUtil.toint("1.0.1".replaceAll("\\.", "")) );
 	}
	/**
	 * 对象转字符串,在长度范围内,超过部分...
	 * @param obj 需转对象
	 * @return 字符串表示
	 */
	public static String toStrByLen(Object obj, int length){
		if (obj == null) {
			return "";
		}
		if(length < 3){
			length = 3;
		}
		if(obj.toString().length() > length){
			return obj.toString().substring(0, length-3) + "...";
		}
		return obj.toString();
	}
	/**
	 * 是否含有表情符号
	 * @param content
	 * @return
	 */
	public static boolean hasEmoji(String content){
	    Pattern pattern = Pattern.compile("[\ud83c\udc00-\ud83c\udfff]|[\ud83d\udc00-\ud83d\udfff]|[\u2600-\u27ff]");
	    Matcher matcher = pattern.matcher(content);
	    if(matcher .find()){
	    	return true;
	    }
	    return false;
	}
}
