package com.hzs.common.core.utils;

import com.hzs.common.core.constant.MagicNumberConstants;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 计算方法的公共方法
 */
public class ComputeUtil {

    /**
     * 统一的除法计算方法
     *
     * @param divisor  除数
     * @param dividend 被除数
     */
    public static BigDecimal computeDivide(BigDecimal divisor, BigDecimal dividend) {
        if (dividend.compareTo(BigDecimal.ZERO) == 0) {
            return BigDecimal.ZERO;
        }
        return divisor.divide(dividend, MagicNumberConstants.DECIMAL, RoundingMode.HALF_UP);
    }

    /**
     * 统一的除法计算方法, 向上取整
     *
     * @param divisor  除数
     * @param dividend 被除数
     */
    public static BigDecimal computeDivideRoundUp(BigDecimal divisor, BigDecimal dividend) {
        if (dividend.compareTo(BigDecimal.ZERO) == 0) {
            return BigDecimal.ZERO;
        }
        return divisor.divide(dividend, MagicNumberConstants.ZERO, BigDecimal.ROUND_UP);
    }

    /**
     * 统一的除法计算方法, 向下取整
     *
     * @param divisor  除数
     * @param dividend 被除数
     */
    public static BigDecimal computeDivideRoundDown(BigDecimal divisor, BigDecimal dividend) {
        if (dividend.compareTo(BigDecimal.ZERO) == 0) {
            return BigDecimal.ZERO;
        }
        return divisor.divide(dividend, MagicNumberConstants.ZERO, BigDecimal.ROUND_DOWN);
    }

    /**
     * 统一的减法计算方法
     *
     * @param subtract  值1
     * @param subtract1 值2
     */
    public static BigDecimal computeSubtract(BigDecimal subtract, BigDecimal subtract1) {
        return subtract.subtract(subtract1);
    }

    /**
     * 统一的减法计算方法, 向下取整
     *
     * @param subtract  值1
     * @param subtract1 值2
     */
    public static BigDecimal computeSubtractAbs(BigDecimal subtract, BigDecimal subtract1) {
        return subtract.subtract(subtract1).abs();
    }

    /**
     * 统一的除法计算方法, 向下取整
     *
     * @param value1 值1
     * @param value2 值2
     */
    public static BigDecimal obtainMinAchieve(BigDecimal value1, BigDecimal value2) {
        if (compareValue(value1, value2)) {
            return value2;
        }
        return value1;
    }

    /**
     * 向上取整
     *
     * @param value 值
     */
    public static BigDecimal mathCeil(BigDecimal value) {
        return BigDecimal.valueOf(Math.ceil(value.doubleValue()));
    }

    /**
     * 计算容量
     *
     * @param size 长度
     * @return int
     */
    public static Integer mapInitCapacity(Integer size) {
        return ((Double) Math.ceil(size / 0.75)).intValue();
    }

    /**
     * 比较大小，前面的值大于等于后面的值
     *
     * @param value1 值1
     * @param value2 值2
     */
    public static Boolean compareValue(BigDecimal value1, BigDecimal value2) {
        if (value1.compareTo(value2) >= 0) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 比较大小，前面的值大于后面的值
     *
     * @param value1 值1
     * @param value2 值2
     */
    public static Boolean compareGreaterThan(BigDecimal value1, BigDecimal value2) {
        if (value1.compareTo(value2) > 0) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 判断2个值是否相等
     *
     * @param value1 值1
     * @param value2 值2
     */
    public static Boolean compareEqual(BigDecimal value1, BigDecimal value2) {
        if (value1.compareTo(value2) == 0) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 比较大小，前面的值大于等于后面的值
     *
     * @param value1 值1
     */
    public static Boolean compareValue(BigDecimal value1) {
        if (value1.compareTo(BigDecimal.ZERO) > 0) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 乘法
     *
     * @param value1 值1
     * @param value2 值2
     */
    public static BigDecimal computeMultiply(BigDecimal value1, Object value2) {
        if (null == value1) {
            return BigDecimal.ZERO;
        }
        if (value2 instanceof BigDecimal) {
            return value1.multiply((BigDecimal) value2);
        } else if (value2 instanceof Integer) {
            return value1.multiply(BigDecimal.valueOf((Integer) value2));
        } else if (value2 instanceof Double) {
            return value1.multiply(BigDecimal.valueOf((Double) value2));
        } else {
            return value1.multiply(BigDecimal.valueOf((Float) value2));
        }
    }

    /**
     * 计算奖金，按照比例计算
     *
     * @param value1 值
     * @param value2 比例
     */
    public static BigDecimal computeBonusMultiply(BigDecimal value1, BigDecimal value2) {
        return value1.multiply(value2).multiply(BigDecimal.valueOf(0.01));
    }

    /**
     * 计算奖金，计算一半
     *
     * @param value1 值
     */
    public static BigDecimal computeMultiplyHalf(BigDecimal value1) {
        return value1.multiply(BigDecimal.valueOf(0.5));
    }

    /**
     * 计算奖金，计算实际
     *
     * @param value1 值
     */
    public static BigDecimal computeMultiplyReal(BigDecimal value1, BigDecimal ratio) {
        return computeBonusMultiply(value1, computeSubtract(BigDecimal.valueOf(100), ratio));
    }

    /**
     * 乘法
     *
     * @param value1 值1
     * @param value2 值2
     */
    public static BigDecimal computeAddNum(BigDecimal value1, BigDecimal... value2) {
        BigDecimal value = null != value1 ? value1 : BigDecimal.ZERO;
        for (BigDecimal bigDecimal : value2) {
            value = value.add(null != bigDecimal ? bigDecimal : BigDecimal.ZERO);
        }
        return value;
    }

    /**
     * 乘法
     *
     * @param value1 值1
     * @param value2 值2
     */
    public static BigDecimal computeAdd(BigDecimal value1, BigDecimal value2) {
        return value1.add(value2);
    }

    /**
     * 乘法
     *
     * @param value1 值1
     * @param value2 值2
     */
    public static BigDecimal computeAddMultiply(BigDecimal value1, BigDecimal value2, Object value3) {
        return value1.add(computeMultiply(value2, value3));
    }
}
