package com.cool.store.utils;

import java.math.BigDecimal;

/**
 * @Auther zx_szh
 * @Date 2026/4/16 10:03
 * @Version 1.0
 */
public class BigDecimalUtils {

    /**
     * 比较两个BigDecimal是否相等（忽略精度差异）
     *
     * @param a 第一个值
     * @param b 第二个值
     * @return 如果相等返回true
     */
    public static boolean equals(BigDecimal a, BigDecimal b) {
        if (a == b) return true;
        if (a == null || b == null) return false;
        return a.compareTo(b) == 0;
    }

    /**
     * 比较两个BigDecimal是否相等（指定精度）
     *
     * @param a       第一个值
     * @param b       第二个值
     * @param scale   保留小数位数
     * @param roundingMode 舍入模式
     * @return 如果相等返回true
     */
    public static boolean equals(BigDecimal a, BigDecimal b, int scale, int roundingMode) {
        if (a == b) return true;
        if (a == null || b == null) return false;
        return a.setScale(scale, roundingMode).compareTo(b.setScale(scale, roundingMode)) == 0;
    }

    /**
     * 判断a是否大于b
     *
     * @param a 第一个值
     * @param b 第二个值
     * @return 如果a大于b返回true
     */
    public static boolean greaterThan(BigDecimal a, BigDecimal b) {
        if (a == null || b == null) return false;
        return a.compareTo(b) > 0;
    }

    /**
     * 判断a是否大于或等于b
     *
     * @param a 第一个值
     * @param b 第二个值
     * @return 如果a大于或等于b返回true
     */
    public static boolean greaterThanOrEqual(BigDecimal a, BigDecimal b) {
        if (a == null || b == null) return false;
        return a.compareTo(b) >= 0;
    }

    /**
     * 判断a是否小于b
     *
     * @param a 第一个值
     * @param b 第二个值
     * @return 如果a小于b返回true
     */
    public static boolean lessThan(BigDecimal a, BigDecimal b) {
        if (a == null || b == null) return false;
        return a.compareTo(b) < 0;
    }

    /**
     * 判断a是否小于或等于b
     *
     * @param a 第一个值
     * @param b 第二个值
     * @return 如果a小于或等于b返回true
     */
    public static boolean lessThanOrEqual(BigDecimal a, BigDecimal b) {
        if (a == null || b == null) return false;
        return a.compareTo(b) <= 0;
    }

    /**
     * 判断value是否在min和max之间（包含边界）
     *
     * @param value 要判断的值
     * @param min   最小值
     * @param max   最大值
     * @return 如果在范围内返回true
     */
    public static boolean between(BigDecimal value, BigDecimal min, BigDecimal max) {
        if (value == null || min == null || max == null) return false;
        return value.compareTo(min) >= 0 && value.compareTo(max) <= 0;
    }

    /**
     * 判断value是否在min和max之间（不包含边界）
     *
     * @param value 要判断的值
     * @param min   最小值
     * @param max   最大值
     * @return 如果在范围内返回true
     */
    public static boolean betweenExclusive(BigDecimal value, BigDecimal min, BigDecimal max) {
        if (value == null || min == null || max == null) return false;
        return value.compareTo(min) > 0 && value.compareTo(max) < 0;
    }

    /**
     * 判断value是否在min和max之间（左闭右开）
     *
     * @param value 要判断的值
     * @param min   最小值（包含）
     * @param max   最大值（不包含）
     * @return 如果在范围内返回true
     */
    public static boolean betweenLeftClosedRightOpen(BigDecimal value, BigDecimal min, BigDecimal max) {
        if (value == null || min == null || max == null) return false;
        return value.compareTo(min) >= 0 && value.compareTo(max) < 0;
    }

    /**
     * 判断value是否在min和max之间（左开右闭）
     *
     * @param value 要判断的值
     * @param min   最小值（不包含）
     * @param max   最大值（包含）
     * @return 如果在范围内返回true
     */
    public static boolean betweenLeftOpenRightClosed(BigDecimal value, BigDecimal min, BigDecimal max) {
        if (value == null || min == null || max == null) return false;
        return value.compareTo(min) > 0 && value.compareTo(max) <= 0;
    }

    /**
     * 判断value是否大于0
     *
     * @param value 要判断的值
     * @return 如果大于0返回true
     */
    public static boolean isPositive(BigDecimal value) {
        return greaterThan(value, BigDecimal.ZERO);
    }

    /**
     * 判断value是否大于或等于0
     *
     * @param value 要判断的值
     * @return 如果大于或等于0返回true
     */
    public static boolean isNonNegative(BigDecimal value) {
        return greaterThanOrEqual(value, BigDecimal.ZERO);
    }

    /**
     * 判断value是否小于0
     *
     * @param value 要判断的值
     * @return 如果小于0返回true
     */
    public static boolean isNegative(BigDecimal value) {
        return lessThan(value, BigDecimal.ZERO);
    }

    /**
     * 判断value是否小于或等于0
     *
     * @param value 要判断的值
     * @return 如果小于或等于0返回true
     */
    public static boolean isNonPositive(BigDecimal value) {
        return lessThanOrEqual(value, BigDecimal.ZERO);
    }

    /**
     * 判断value是否等于0
     *
     * @param value 要判断的值
     * @return 如果等于0返回true
     */
    public static boolean isZero(BigDecimal value) {
        return equals(value, BigDecimal.ZERO);
    }

    /**
     * 判断value是否非零
     *
     * @param value 要判断的值
     * @return 如果不等于0返回true
     */
    public static boolean isNotZero(BigDecimal value) {
        return !isZero(value);
    }

    /**
     * 判断两个BigDecimal中的较大值
     *
     * @param a 第一个值
     * @param b 第二个值
     * @return 较大值，如果都为null返回null
     */
    public static BigDecimal max(BigDecimal a, BigDecimal b) {
        if (a == null) return b;
        if (b == null) return a;
        return a.compareTo(b) >= 0 ? a : b;
    }

    /**
     * 判断两个BigDecimal中的较小值
     *
     * @param a 第一个值
     * @param b 第二个值
     * @return 较小值，如果都为null返回null
     */
    public static BigDecimal min(BigDecimal a, BigDecimal b) {
        if (a == null) return b;
        if (b == null) return a;
        return a.compareTo(b) <= 0 ? a : b;
    }

    /**
     * 安全比较，处理null情况
     *
     * @param a 第一个值
     * @param b 第二个值
     * @return 比较结果：a>b返回1，a=b返回0，a<b返回-1
     */
    public static int safeCompare(BigDecimal a, BigDecimal b) {
        if (a == null && b == null) return 0;
        if (a == null) return -1;
        if (b == null) return 1;
        return a.compareTo(b);
    }

}