package com.irrigation.icl.utils;

import com.irrigation.icl.exception.ContextRuntimeException;

import javax.annotation.Nonnull;
import java.math.BigDecimal;
import java.util.Objects;
import java.util.Optional;

/**
 * @description: 浮点数操作工具类
 * @Author: yangLang
 * @CreateDate: 2020/4/29 16:09
 */
public final class DoubleValueUtils {

    /**
     * 默认保留位数
     */
    private final static int SCALE = 4;


    /**
     * Double 0.0
     */
    public final static Double DOUBLE_ZERO = Double.valueOf(0.0d);

    /**
     * double 0.0
     */
    public final static double ZERO = 0.0d;


    private DoubleValueUtils() {
    }

    /**
     * 计算两个浮点数之和s
     *
     * @param value    加数
     * @param addValue 被加数
     * @return 返回结果四舍五入，保留4位小数
     * @Author: yangLang
     */
    public static double doubleAdd(Double value, Double addValue) {
        value = Optional.ofNullable(value).orElse(DOUBLE_ZERO);
        addValue = Optional.ofNullable(addValue).orElse(DOUBLE_ZERO);
        return new BigDecimal(value.toString()).add(new BigDecimal(addValue.toString()))
                .setScale(SCALE, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 计算两个浮点数之和
     *
     * @param value    加数
     * @param addValue 被加数
     * @param scale    保留位数
     * @return 返回结果四舍五入，保留4位小数
     * @Author: yangLang
     */
    public static double doubleAdd(Double value, Double addValue, int scale) {
        value = Optional.ofNullable(value).orElse(DOUBLE_ZERO);
        addValue = Optional.ofNullable(addValue).orElse(DOUBLE_ZERO);
        return new BigDecimal(value.toString()).add(new BigDecimal(addValue.toString()))
                .setScale(scale, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 计算两个浮点数之差
     *
     * @param value    减数
     * @param subValue 被减数
     * @return 返回结果四舍五入，保留4位小数
     * @author: yangLang
     */
    public static double doubleSub(Double value, Double subValue) {
        value = Optional.ofNullable(value).orElse(DOUBLE_ZERO);
        subValue = Optional.ofNullable(subValue).orElse(DOUBLE_ZERO);
        return new BigDecimal(value.toString()).subtract(new BigDecimal(subValue.toString()))
                .setScale(SCALE, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 计算两个浮点数之差
     *
     * @param value    减数
     * @param subValue 被减数
     * @param scale    保留位数
     * @return 返回结果四舍五入，保留4位小数
     * @author: yangLang
     */
    public static double doubleSub(Double value, Double subValue, int scale) {
        value = Optional.ofNullable(value).orElse(DOUBLE_ZERO);
        subValue = Optional.ofNullable(subValue).orElse(DOUBLE_ZERO);
        return new BigDecimal(value.toString()).subtract(new BigDecimal(subValue.toString()))
                .setScale(scale, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 计算两个浮点数之积
     *
     * @param value    乘数
     * @param mutValue 被乘数
     * @return 返回结果四舍五入，保留4位小数
     * @author: yangLang
     */
    public static double doubleMulti(Double value, Double mutValue) {
        value = Optional.ofNullable(value).orElse(DOUBLE_ZERO);
        mutValue = Optional.ofNullable(mutValue).orElse(DOUBLE_ZERO);
        return new BigDecimal(value.toString()).multiply(new BigDecimal(mutValue.toString()))
                .setScale(SCALE, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 计算两个浮点数之积
     *
     * @param value    乘数
     * @param mutValue 被乘数
     * @param scale    保留位数
     * @return 返回结果四舍五入，保留4位小数
     * @author: yangLang
     */
    public static double doubleMulti(Double value, Double mutValue, int scale) {
        value = Optional.ofNullable(value).orElse(DOUBLE_ZERO);
        mutValue = Optional.ofNullable(mutValue).orElse(DOUBLE_ZERO);
        return new BigDecimal(value.toString()).multiply(new BigDecimal(mutValue.toString()))
                .setScale(scale, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 计算两个浮点数之商
     *
     * @param value    除数
     * @param divValue 被除数
     * @return 返回结果四舍五入，保留4位小数
     * @author: yangLang
     */
    public static double doubleDiv(Double value, @Nonnull Double divValue) {
        value = Optional.ofNullable(value).orElse(DOUBLE_ZERO);
        validateDivValue(divValue);
        return new BigDecimal(value.toString()).divide(new BigDecimal(divValue.toString()))
                .setScale(SCALE, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 计算两个浮点数之商
     *
     * @param value    除数
     * @param divValue 被除数
     * @param scale    保留位数
     * @return 返回结果四舍五入，保留4位小数
     * @author: yangLang
     */
    public static double doubleDiv(Double value, @Nonnull Double divValue, int scale) {
        value = Optional.ofNullable(value).orElse(DOUBLE_ZERO);
        validateDivValue(divValue);
        return new BigDecimal(value.toString()).divide(new BigDecimal(divValue.toString()))
                .setScale(scale, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 检查除数是否为0
     *
     * @param divValue
     * @return
     * @author: yangLang
     */
    private static Double validateDivValue(@Nonnull Double divValue) {
        Objects.requireNonNull(divValue, "被除数不能为空");
        if (ZERO == divValue.doubleValue()) {
            throw new ContextRuntimeException("被除数不能为0");
        }
        return divValue;
    }

}