package com.ruoyi.quality.utils;

import java.math.BigDecimal;

/**
 * 质检参数判断工具类
 */
public class QualityJudgeUtil {

    public static final String JUDGE_TYPE_GREATER_EQUAL = "大于等于";
    public static final String JUDGE_TYPE_LESS_EQUAL = "小于等于";
    public static final String JUDGE_TYPE_RANGE = "范围";
    public static final String JUDGE_TYPE_TEXT_DESCRIPTION = "文字描述";

    /**
     * 判断参数项是否合格
     *
     * @param testValue     检验值
     * @param standardValue 标准值（大于等于、小于等于类型使用）
     * @param minValue      范围下限值（范围类型使用）
     * @param maxValue      范围上限值（范围类型使用）
     * @param judgeType     判断类型
     * @return 判断结果对象
     */
    public static JudgeResult judge(String testValue, String standardValue,
                                    BigDecimal minValue, BigDecimal maxValue, String judgeType) {
        JudgeResult result = new JudgeResult();

        // 文字描述类型不自动判断
        if (JUDGE_TYPE_TEXT_DESCRIPTION.equals(judgeType)) {
            result.setQualified(null);
            result.setMessage("文字描述类型需手动判断");
            return result;
        }

        // 检验值为空时无法判断
        if (testValue == null || testValue.trim().isEmpty()) {
            result.setQualified(null);
            result.setMessage("检验值为空，无法判断");
            return result;
        }

        try {
            BigDecimal testVal = new BigDecimal(testValue.trim());

            switch (judgeType) {
                case JUDGE_TYPE_GREATER_EQUAL:
                    return judgeGreaterEqual(testVal, standardValue);
                case JUDGE_TYPE_LESS_EQUAL:
                    return judgeLessEqual(testVal, standardValue);
                case JUDGE_TYPE_RANGE:
                    return judgeRange(testVal, minValue, maxValue);
                default:
                    result.setQualified(null);
                    result.setMessage("未知的判断类型：" + judgeType);
                    return result;
            }
        } catch (NumberFormatException e) {
            result.setQualified(null);
            result.setMessage("检验值格式不正确，无法转换为数值");
            return result;
        }
    }

    /**
     * 大于等于判断
     */
    private static JudgeResult judgeGreaterEqual(BigDecimal testValue, String standardValue) {
        JudgeResult result = new JudgeResult();
        try {
            BigDecimal standardVal = new BigDecimal(standardValue.trim());
            boolean qualified = testValue.compareTo(standardVal) >= 0;
            result.setQualified(qualified);
            result.setMessage(String.format("检验值%s >= 标准值%s，%s",
                    testValue, standardVal, qualified ? "合格" : "不合格"));
        } catch (Exception e) {
            result.setQualified(null);
            result.setMessage("标准值格式不正确：" + standardValue);
        }
        return result;
    }

    /**
     * 小于等于判断
     */
    private static JudgeResult judgeLessEqual(BigDecimal testValue, String standardValue) {
        JudgeResult result = new JudgeResult();
        try {
            BigDecimal standardVal = new BigDecimal(standardValue.trim());
            boolean qualified = testValue.compareTo(standardVal) <= 0;
            result.setQualified(qualified);
            result.setMessage(String.format("检验值%s <= 标准值%s，%s",
                    testValue, standardVal, qualified ? "合格" : "不合格"));
        } catch (Exception e) {
            result.setQualified(null);
            result.setMessage("标准值格式不正确：" + standardValue);
        }
        return result;
    }

    /**
     * 范围判断
     */
    private static JudgeResult judgeRange(BigDecimal testValue, BigDecimal minValue, BigDecimal maxValue) {
        JudgeResult result = new JudgeResult();
        if (minValue == null || maxValue == null) {
            result.setQualified(null);
            result.setMessage("范围类型的上下限值不能为空");
            return result;
        }
        boolean qualified = testValue.compareTo(minValue) >= 0 && testValue.compareTo(maxValue) <= 0;
        result.setQualified(qualified);
        result.setMessage(String.format("检验值%s在范围[%s, %s]%s，%s",
                testValue, minValue, maxValue,
                qualified ? "内" : "外", qualified ? "合格" : "不合格"));
        return result;
    }

    /**
     * 判断结果对象
     */
    public static class JudgeResult {
        private Boolean qualified;
        private String message;

        public Boolean getQualified() {
            return qualified;
        }

        public void setQualified(Boolean qualified) {
            this.qualified = qualified;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }
    }
}