package com.fxy.utils;

import java.math.BigDecimal;

public class ValueUtils {

    // 默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    /**
     * 构造函数
     */
    private ValueUtils() {

    }

    /**
     * 将对象转换成字符串
     *
     * @param obj
     *            对象
     * @param defaultValue
     *            默认值，当字符串为空时返回默认值
     * @return 字符串
     */
    public static String getString(Object obj, String defaultValue) {
        if (obj != null && obj.toString().length() > 0) {
            return obj.toString().trim();
        }
        return defaultValue;
    }

    /**
     * 将对象转换成字符串
     *
     * @param obj
     *            对象
     * @return 字符串
     */
    public static String getString(Object obj) {
        return getString(obj, "");
    }

    /**
     * 将对象转换成布尔值
     *
     * @param obj
     *            对象
     * @param defaultValue
     *            默认值,当传入对象为null时返回默认值
     * @return 布尔值
     */
    public static boolean getBoolean(Object obj, boolean defaultValue) {
        if (obj != null) {
            if (obj instanceof Boolean) {
                return ((Boolean) obj).booleanValue();
            } else {
                String str = obj.toString().trim();
                return "Y".equalsIgnoreCase(str) || "TRUE".equalsIgnoreCase(str) || "1".equals(str);

            }
        }
        return defaultValue;
    }

    /**
     * 将对象转换成布尔值
     *
     * @param obj
     *            对象
     * @return 布尔值
     */
    public static boolean getBoolean(Object obj) {
        return getBoolean(obj, false);
    }

    /**
     * 将对象转换成数字
     *
     * @param obj
     *            对象
     * @param defaultValue
     *            默认值，当传入对象为null时返回默认值
     * @return 数字
     */
    public static Integer getInteger(Object obj, int defaultValue) {
        if (obj != null && obj != "") {
            if (obj instanceof Integer) {
                return ((Integer) obj).intValue();
            } else {
                try {
                    return Integer.parseInt(obj.toString().trim());
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
            }
        }
        return defaultValue;
    }

    /**
     * 将对象转换成数字
     *
     * @param obj
     *            对象
     * @return 数字
     */
    public static Integer getInteger(Object obj) {
        return getInteger(obj,0);
    }

    /**
     * 将对象转换成长整型
     *
     * @param obj
     *            对象
     * @param defaultValue
     *            默认值，当传入对象为null时返回默认值
     * @return 长整型数字
     */
    public static Long getLong(Object obj, long defaultValue) {
        if (obj != null) {
            if (obj instanceof Long) {
                return ((Long) obj).longValue();
            } else {
                try {
                    return Long.valueOf(obj.toString().trim());
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
            }
        }
        return defaultValue;
    }

    /**
     * 将对象转换成长整型
     *
     * @param obj
     *            对象
     * @return 长整型数字
     */
    public static Long getLong(Object obj) {
        return getLong(obj, 0L);
    }

    /**
     * 将对象转换成双精度型小数
     *
     * @param obj
     *            对象
     * @param defaultValue
     *            默认值，当传入对象为null时返回默认值
     * @return 双精度型小数
     */
    public static Double getDouble(Object obj, double defaultValue) {
        if (obj != null) {
            if (obj instanceof Double) {
                return ((Double) obj).doubleValue();
            } else {
                try {
                    return Double.valueOf(obj.toString().trim());
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
            }
        }
        return defaultValue;
    }

    /**
     * 将对象转换成双精度型小数
     *
     * @param obj
     *            对象
     * @return 双精度型小数
     */
    public static Double getDouble(Object obj) {
        return getDouble(obj, 0d);
    }

    /**
     * 将对象转换成双精度型小数
     *
     * @param obj
     *            对象
     * @param defaultValue
     *            默认值，当传入对象为null时返回默认值
     * @return 双精度型小数
     */
    public static BigDecimal getBigDecimal(Object obj, BigDecimal defaultValue) {
        if (obj != null) {
            if (obj instanceof BigDecimal) {
                return (BigDecimal) obj;
            } else {
                try {
                    return new BigDecimal(obj.toString().trim());
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
            }
        }
        return defaultValue;
    }

    /**
     * 将对象转换成双精度型小数
     *
     * @param obj
     *            对象
     * @return 双精度型小数
     */
    public static BigDecimal getBigDecimal(Object obj) {
        return getBigDecimal(obj, BigDecimal.ZERO);
    }

    /**
     * double 转 BigDecimal
     *
     * @param value
     * @return
     */
    public static BigDecimal getBigDecimal(Double value){
        if(null == value){
            return new BigDecimal("0.0000");
        }
        return new BigDecimal(Double.toString(value));
    }

    /**
     * Obj 转 BigDecimal
     *
     * @param obj
     * @return
     */
    public static BigDecimal toBigDecimal(Object obj){
        if(null == obj){
            return BigDecimal.ZERO;
        }
        return new BigDecimal(obj.toString());
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1
     *            被减数
     * @param v2
     *            减数
     * @return 两个参数的差
     */
    public static Double sub(Double v1, Double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的加法运算。
     *
     * @param v1
     *            被加数
     * @param v2
     *            加数
     * @return 两个参数的和
     */
    public static Double add(Double v1, Double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算。
     *
     * @param v1
     *            被乘数
     * @param v2
     *            乘数
     * @return 两个参数的积
     */
    public static Double mul(Double v1, Double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。
     *
     * @param v1
     *            被除数
     * @param v2
     *            除数
     * @return 两个参数的商
     */
    public static Double div(Double v1, Double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
     *
     * @param v1
     *            被除数
     * @param v2
     *            除数
     * @param scale
     *            表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static Double div(Double v1, Double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * Integer to String
     * @param value
     * @return
     */
    public static String convertIntToString(Integer value){
        if(value != null){
            return value +"";
        }
        return "";
    }


}
