package com.hx.util;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 数字工具
 * 
 * @author mgchen
 *
 */
public class NumberUtil {

    private static DecimalFormat fmt = new DecimalFormat("0.00");

    private static DecimalFormat fmtOne = new DecimalFormat("0.0");

    private static DecimalFormat fmtThree = new DecimalFormat("0.000");

    /**
     * 获取指定格式的Double 类型数据
     * @param e
     *            要转换的数据源
     **/
    public static Double getTypeDouble(Double e) {
        fmt.setRoundingMode(RoundingMode.HALF_UP); // 保留小数点后两位并四舍五入，确保价钱准确
        Double d = Double.valueOf(fmt.format(e));
        return d;
    }

    /**
     * 获取指定格式的Double 类型数据
     *
     * @param e
     *            要转换的数据源
     **/
    public static Double getTypeDouble1(Double e) {
        fmtOne.setRoundingMode(RoundingMode.HALF_UP); // 保留小数点后两位并四舍五入，确保价钱准确
        Double d = Double.valueOf(fmtOne.format(e));
        return d;
    }

    public static Double getTypeDouble2(Double e) {
        fmtThree.setRoundingMode(RoundingMode.HALF_UP); // 保留小数点后两位并四舍五入，确保价钱准确
        Double d = Double.valueOf(fmtThree.format(e));
        return d;
    }

    /**
     * 把存储的分字符串转成元的浮点数 例如100到1.0
     */
    public static Double getYunFromFenStr(String fenStr) {
        return getTypeDouble(Integer.parseInt(fenStr) * 1.0 / 100);
    }

    /**
     * 把存储的分转成元的浮点数 例如100到1.0
     */
    public static Double getYunFromFen(Integer fen) {
        if (fen == null) {
            return 0D;
        }
        return getTypeDouble(fen * 1.0 / 100);
    }

    /**
     * 把存储的厘转成元的浮点数 例如1000到1.0
     */
    public static Double getYunFromLi(int li) {
        return getTypeDouble2(li * 1.0 / 1000);
    }

    /**
     * 把存储的数值转为百分比
     * 
     * @param rate
     * @return
     */
    public static Double getRateFromInt(int rate) {
        return getTypeDouble(rate * 1.0 / 100);
    }

    /** 浮点数四舍五入取整 */
    public static int getRoundHalfUp(double tar) {
        return new BigDecimal(tar).setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
    }

    /** 浮点数四舍五入取整 */
    public static int getRoundHalfDown(double tar) {
        Double d = Math.floor(tar);
        return d.intValue();
    }

    /**
     * 把一个double的字符串乘100 返回整数
     *
     * @return int 整数
     */
    public static int getYunFromFen(String str) {
        // BigDecimal b1 = new BigDecimal(str);
        // BigDecimal b2 = new BigDecimal("100");
        // return b1.multiply(b2).intValue();
        return multiply(str, "100").intValue();
    }

    /** 获取两位小数的整数 */
    public static int getTwoDecimalInt(Double d) {
        return Double.valueOf(fmt.format(d)).intValue();
    }

    /**
     * num1 除以num2 得到百分百 保留一位小数
     * 
     * @param num1
     * @param num2
     * @return
     */
    public static Double getPercentage(Integer num1, Integer num2) {
        Double reNum = 0d;
        if (num1 == null || num2 == null || num1 == 0 || num2 == 0) {
            return reNum;
        }
        BigDecimal b1 = new BigDecimal(num1 * 100);
        BigDecimal b2 = new BigDecimal(num2);
        reNum = b1.divide(b2, 1, BigDecimal.ROUND_HALF_UP).doubleValue();
        return reNum;
    }

    /**
     * 将一个数除以100
     * 
     * @param fen
     * @return Double
     */
    public static Double fenForYuan(int fen) {
        // BigDecimal b1 = new BigDecimal(fen);
        // BigDecimal b2 = new BigDecimal(100);
        // return b1.divide(b2).doubleValue();
        return divide(fen, 100);
    }

    /**
     * 将一个数除以100
     * 
     * @param fen
     * @return Double
     */
    public static Double fenForYuan(String fen) {
        // BigDecimal b1 = new BigDecimal(fen);
        // BigDecimal b2 = new BigDecimal(100);
        // return b1.divide(b2).doubleValue();
        return divide(fen, "100");
    }

    public static void main(String[] args) {
        double d = 299999d;
        System.out.println(getTwoOfDouble(d));
    }

    /**
     * 两个数相除
     * 
     * @param num1
     *            数字1
     * @param num2
     *            数字2
     * @return
     */
    public static Double divide(int num1, int num2) {
        return divide(num1 * 1D, num2 * 1D);
    }

    /**
     * 两个数相除- 保留两位小数点
     * 
     * @param num1
     *            数字1
     * @param num2
     *            数字2
     * @return
     */
    public static Double divide(String num1, String num2) {
        return divide(Double.parseDouble(num1), Double.parseDouble(num1), 2);
    }

    /**
     * 两个数相除- 保留两位小数点
     * 
     * @param num1
     *            数字1
     * @param num2
     *            数字2
     * @return
     */
    public static Double divide(Double num1, Double num2) {
        return divide(num1, num2, 2);
    }

    /**
     * 两个数相除
     * 
     * @param num1
     *            数字1
     * @param num2
     *            数字2
     * @param scale
     *            小数位数， 默认保留2位
     * @return
     */
    public static Double divide(Double num1, Double num2, Integer scale) {
        if (scale == null || scale < 0) {
            scale = 2;
        }
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 
     * 两个数相除
     *
     * @param num1
     *            数字1
     * @param num2
     *            数字2
     * @param scale
     *            小数位数， 默认保留2位
     * @return
     */
    public static Double divideDown(Double num1, Double num2, Integer scale) {
        if (scale == null || scale < 0) {
            scale = 2;
        }
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);

        return b1.divide(b2, scale, BigDecimal.ROUND_DOWN).doubleValue();
    }

    /**
     * 两个Double数相乘
     * 
     * @param num1
     * @param num2
     * @return Double
     * 
     */
    public static Double multiply(Double num1, Double num2) {
        return multiply(num1.toString(), num2.toString());
    }

    /**
     * 两个Double数相乘
     * 
     * @param num1
     * @param num2
     * @return Double
     * 
     */
    public static Double multiply(String num1, String num2) {
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 两个Double数相减
     * 
     * @param v1
     * @param v2
     * @return Double
     */
    public static Double subtract(Double v1, Double v2) {
        return subtract(v2.toString(), v2.toString());
    }

    /**
     * 两个Double数相减
     * 
     * @param v1
     * @param v2
     * @return Double
     */
    public static Double subtract(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 两个Double数相加
     * 
     * @param v1
     * @param v2
     * @return Double
     */
    public static Double add(Double v1, Double v2) {
        return add(v1.toString(), v2.toString());
    }

    /**
     * 两个Double数相加
     * 
     * @param v1
     * @param v2
     * @return Double
     */
    public static Double add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).doubleValue();
    }

    /** 从元转化为分，元为2位小数 */
    public static int getFenFromYun(String doubleStr) {
        return getRoundHalfUp(Double.parseDouble(doubleStr) * 100);
    }

    /**获取两位小数的字符串*/
    public static String getTwoOfDouble(double value)
    {
        String str = value + "";

        //如果有小数点，则两位小数
        int pointIndex = str.indexOf(".");
        if(pointIndex != -1)
        {
            int len = str.length();
            if(len - (pointIndex + 1) > 2)
            {
                return str.substring(0, pointIndex + 3);
            }
        }

        return str;
    }

    /**Double类型转化
     * @param data 数据
     * @param digitNumber 保留多少位小数
     * @return
     */
    public static Double getTypeDouble(Double data,Integer digitNumber) {
        //利用BigDecimal来实现四舍五入.保留一位小数
        double result2 = new BigDecimal(data).setScale(digitNumber, BigDecimal.ROUND_HALF_UP).doubleValue();
        //1代表保留1位小数,保留两位小数就是2
        //BigDecimal.ROUND_HALF_UP 代表使用四舍五入的方式

        return result2;
    }

    /**
     * 从字符串中提取小数
     * @param str
     * @return
     */
    public static String getNumber(String str){
        // 控制正则表达式的匹配行为的参数(小数)
        Pattern p = Pattern.compile("(\\d+\\.\\d+)");
        //Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例.
        Matcher m = p.matcher(str);
        //m.find用来判断该字符串中是否含有与"(\\d+\\.\\d+)"相匹配的子串
        if (m.find()) {
            //如果有相匹配的,则判断是否为null操作
            //group()中的参数：0表示匹配整个正则，1表示匹配第一个括号的正则,2表示匹配第二个正则,在这只有一个括号,即1和0是一样的
            str = m.group(1) == null ? "" : m.group(1);
        } else {
            //如果匹配不到小数，就进行整数匹配
            p = Pattern.compile("(\\d+)");
            m = p.matcher(str);
            if (m.find()) {
                //如果有整数相匹配
                str = m.group(1) == null ? "" : m.group(1);
            } else {
                //如果没有小数和整数相匹配,即字符串中没有整数和小数，就设为空
                str = "";
            }
        }
        return str;
    }

    /** 校验字符串是否整数 */
    public static boolean checkStrIsInt(String str){
        if(StringUtils.isEmpty(str)){
            return false;
        }
        try{
            Integer.parseInt(str);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /**
     * 字符串转整形
     * @param str
     * @param defInt    默认整数
     * @return
     */
    public static int strChangeInt(String str, Integer defInt){
        if(defInt == null){
            defInt = 0;
        }
        if(StringUtils.isEmpty(str)){
            return defInt;
        }
        try{
            return Integer.parseInt(str);
        }catch (Exception e){
            return defInt;
        }
    }
}