package com.unis.crk.utils;

import cn.hutool.core.util.ObjectUtil;
import java.math.BigDecimal;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 质检环节质量指标结算
 * All rights Reserved, Designed By RDA 
 * @package ： com.ls.report.util 
 * @classname ： QualityCheckUtil    
 * @author : wangkexin  
 * @date : 2016-11-22 
 * @description : TODO(这里用一句话描述这个类的作用)    
 *
 */
public class QualityCheckUtil {

	/**
	 * 获取标准值
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return Map<String,Object>
	 * @throws Exception 
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getStandardValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("BZZ"))){
			throw new Exception("标准值不存在");
		}
		
		BigDecimal bzz = new BigDecimal(amountMap.get("BZZ")+"");
		
		return bzz.setScale(2, BigDecimal.ROUND_HALF_UP);
		
	}
	
	/**
	 * 获取不计扣量的值
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return BigDecimal
	 * @throws Exception 
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getNoCalculationValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("KLIGNORED"))){
			//throw new Exception("不计扣量值不存在");
			return new BigDecimal("-999");
		}
		
		BigDecimal bjkl = new BigDecimal(amountMap.get("KLIGNORED")+"");
		
		return bjkl.setScale(2, BigDecimal.ROUND_HALF_UP);
	} 
	
	/**
	 * 获取拒收下线
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return BigDecimal
	 * @throws Exception 
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getExtremeValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("JSLOWERLIMIT"))){
			//throw new Exception("极值不存在");
			return new BigDecimal("-999");
		}
		
		BigDecimal jz = new BigDecimal(amountMap.get("JSLOWERLIMIT")+"");
		
		return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	/**
	 * 获取拒收上线
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return BigDecimal
	 * @throws Exception 
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getExtremeValue_up(Map<String, Object> amountMap) throws Exception {
	  
	  if(ObjectUtil.isAllEmpty(amountMap.get("JSUPPERLIMIT"))){
	    //throw new Exception("极值不存在");
	    return new BigDecimal("-999");
	  }
	  
	  BigDecimal jz = new BigDecimal(amountMap.get("JSUPPERLIMIT")+"");
	  
	  return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	
	
	/**
	 * 获取不再增量值
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return BigDecimal
	 * @throws Exception 
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getIgnoredValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("ZLIGNORED"))){
			//throw new Exception("不再增量值不存在");
			return new BigDecimal("-999");
		}
		
		BigDecimal jz = new BigDecimal(amountMap.get("ZLIGNORED")+"");
		
		return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	
	
	/**
	 * 拒收上线
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return BigDecimal
	 * @throws Exception 
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getUpperLimitValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("JSUPPERLIMIT"))){
			//throw new Exception("拒收上限不存在");
			return new BigDecimal("-999");
		}
		
		BigDecimal jz = new BigDecimal(amountMap.get("JSUPPERLIMIT")+"");
		
		return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	
	
	/**
	 *  获取扣量比
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @throws Exception
	 * @return BigDecimal
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getDeductionsValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("KLRANGE"))){
//			throw new Exception("扣量比不存在");
			//默认0
			amountMap.put("KLRANGE",0.0);
		}
		
		BigDecimal jz = new BigDecimal(amountMap.get("KLRANGE")+"");
		
		return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	
	
	/**
	 *  获取增量比
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @throws Exception
	 * @return BigDecimal
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getIncrementValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("ZLRANGE"))){
//			throw new Exception("增量比不存在");
			//默认0
			amountMap.put("ZLRANGE",0.0);
		}
		
		BigDecimal jz = new BigDecimal(amountMap.get("ZLRANGE")+"");
		
		return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	
	
	/**
	 * 获取map实例
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return Map<String,Object>
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	public static Map<String,Object> getMapInstance() {
		return new LinkedHashMap<String, Object>();
	}
	
	/**
	 * 获取增扣量系数
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @throws Exception
	 * @return BigDecimal
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getAmountRatioValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("KLUPPERLIMIT"))){
//			throw new Exception("扣量系数不存在");
			amountMap.put("KLUPPERLIMIT",0.0);
		}
		
		BigDecimal jz = new BigDecimal(amountMap.get("KLUPPERLIMIT")+"");
		
		return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	
	/**
	 * 获取增扣价系数
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @throws Exception
	 * @return BigDecimal
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getPriceRatioValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("KJUPPERLIMIT"))){
			//throw new Exception("扣价系数不存在");
			return new BigDecimal("-999");
		}
		
		BigDecimal jz = new BigDecimal(amountMap.get("KJUPPERLIMIT")+"");
		
		return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	
	/**
	 * 获取扣价比
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @throws Exception
	 * @return BigDecimal
	 * @description TODO(这里用一句话描述这个方法的作用)
	 */
	protected static BigDecimal getDiffPriceValue(Map<String, Object> amountMap) throws Exception {
		
		if(ObjectUtil.isAllEmpty(amountMap.get("KJRANGE"))){
			//throw new Exception("扣价比不存在");
			return new BigDecimal("-999");
		}
		
		BigDecimal jz = new BigDecimal(amountMap.get("KJRANGE")+"");
		
		return jz.setScale(2, BigDecimal.ROUND_HALF_UP);
	}
	
	
	/**
	 * 获取玉米水分增扣量、增扣价
	 * 
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return Map<String, Object>
	 * @throws Exception
	 * @description ：
	 * 
	 * 水分公式：
	 * 	增扣量百分比＝（标准值－检验值）/系数＊增扣量比
	 * 	烘干费用＝结算总价款＊［（标准值－检验值）/系数＊扣价比］
	 * 约束：
	 * 	1、|标准值－检验值|﹤0.5%，不计增扣量和增扣价,增扣量和增扣价为0；
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量
	 * 	3、标准值－检验值﹥极值时，不再增量；
	 * 
	 */
	public static Map<String, Object> getCornMoistureMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception {
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap);
		
		//不再增扣量
		BigDecimal jz = getIgnoredValue(amountMap);
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		if(!jz.equals(new BigDecimal("-999"))){
			//3、标准值－检验值﹥极值时，不再增量；
			if(sub.compareTo(jz) == 1){
				sub = jz;
			}
		}
		
		//2、公式计算结果为正数是增量，计算结果为负数是扣量
		if(sub.signum() == -1){
			//扣量比
			BigDecimal klb = getDeductionsValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊扣量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb);
		}else{
			//增量比
			BigDecimal zlb = getIncrementValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊增量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(zlb);
		}
		
		//获取增扣价系数
		BigDecimal priceRatio = getPriceRatioValue(amountMap);
		
		//获取扣价比
		BigDecimal kjb = getDiffPriceValue(amountMap);
		 //增扣价系数 或者 扣价比 不对，则返回0
		if(priceRatio.equals(new BigDecimal("-999")) || kjb.equals(new BigDecimal("-999"))){
			zkj = new BigDecimal("0");
		}else{
			
			if(priceRatio.compareTo(new BigDecimal("0")) == 0){
				throw new Exception("增扣价系数为零");
			} 
			//计算水分扣价  （标准值－检验值）/系数＊扣价比）
			zkj = sub.divideAndRemainder(priceRatio)[0].multiply(kjb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	/**
	 * 获取玉米生霉粒扣价
	 * 
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @return Map<String, Object>
	 * @throws Exception
	 * @description ：
	 * 
	 * 水分公式：
	 * 	烘干费用＝结算总价款＊［（标准值－检验值）/系数＊扣价比］
	 * 约束：
	 * 	1、检验 >最大限定值(5%)，不收
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量
	 * 	3、标准值－检验值﹥0，不增量；
	 * 
	 */
	public static Map<String, Object> getCornMildewMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception {
	  
	  Map<String, Object> resultMap = null;
	  
	  //标准值
	  BigDecimal bzz = getStandardValue(amountMap);
	  
	  //检验值
	  BigDecimal jyz = checkValue;
	  
	  
	  //标准值－检验值
	  BigDecimal sub = bzz.subtract(jyz);
	  
	  
	  //增扣量百分比
	  BigDecimal zkl = new BigDecimal("0");
	  
	  //增扣价百分比
	  BigDecimal zkj = new BigDecimal("0");
	  
	  if (bzz.compareTo(jyz) == 1) {  //低于标准值，返回扣价0
	    resultMap = getMapInstance();
	    resultMap.put("amount", zkl);
	    resultMap.put("price", zkj);
	    return resultMap; 
    }
	  
    //拒收上限
    BigDecimal jssx = getExtremeValue_up(amountMap);
    
    if(!jssx.equals(new BigDecimal("-999"))){
      //含量超过5%的，不得收购
      if(checkValue.compareTo(jssx) == 1 || checkValue.compareTo(jssx) == 0){
        throw new Exception("含量超过"+jssx.setScale(2, BigDecimal.ROUND_HALF_UP)+"%的，不得收购");
      }
    }
	  
	 
	  //获取增扣价系数
	  BigDecimal priceRatio = getPriceRatioValue(amountMap);
	  
	  //获取扣价比
	  BigDecimal kjb = getDiffPriceValue(amountMap);
	  //增扣价系数 或者 扣价比 不对，则返回0
	  if(priceRatio.equals(new BigDecimal("-999")) || kjb.equals(new BigDecimal("-999"))){
	    zkj = new BigDecimal("0");
	  }else{
	    
	    if(priceRatio.compareTo(new BigDecimal("0")) == 0){
	      throw new Exception("增扣价系数为零");
	    } 
	    //计算水分扣价  （标准值－检验值）/系数＊扣价比）
	    zkj = sub.divide(priceRatio).multiply(kjb).setScale(2, BigDecimal.ROUND_HALF_UP);
	  }
	  
	  resultMap = getMapInstance();
	  resultMap.put("amount", zkl);
	  resultMap.put("price", zkj);
	  
	  return resultMap;
	  
	}
	
	
	
	/**
	 * 获取玉米杂质
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description :
	 * 公式：
	 * 	增扣量百分比＝（标准值－检验值）/系数＊增扣量比
	 * 约束：
	 * 	1、|标准值－检验值|﹤0.5，不计增扣量和增扣价。
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量
	 * 
	 * 	注：玉米杂质没有增扣价
	 *
	 */
	public static Map<String, Object> getCornImpurityMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		if(!bjkl.equals(new BigDecimal("-999"))){
			//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//2、公式计算结果为正数是增量，计算结果为负数是扣量
		if(sub.signum() == -1){
			//扣量比
			BigDecimal klb = getDeductionsValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊扣量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}else{
			//增量比
			BigDecimal zlb = getIncrementValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊增量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(zlb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	
	
	/**
	 * 获取玉米不完善粒
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 不完善粒公式：
	 * 	扣量百分比＝（标准值－检验值）/系数＊扣量比
	 * 约束：
	 * 	1、|标准值－检验值|﹤0.5，不计扣量。
	 * 	2、无增量。
	 */
	public static Map<String, Object> getCornUnsoundGrainMap(Map<String, Object> amountMap,BigDecimal standardValue, BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = standardValue;
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//扣量比
		BigDecimal klb = getDeductionsValue(amountMap);
		//增扣量百分比＝（标准值－检验值）/系数＊扣量比 注： 不完善粒没有增量
		zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
	}
	
	/**
	 * 获取稻谷水分
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 水分公式：
	 * 	增扣量百分比＝（标准值－检验值）/系数＊增扣量比
	 * 约束：
	 * 	1、|标准值－检验值|﹤0.5，不计增扣量和增扣价。
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量
	 */
	public static Map<String, Object> getPaddyMoistureMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception {
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap);
		
		//极值
		BigDecimal jz = getIgnoredValue(amountMap);
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//3、标准值－检验值﹥极值时，不再增量；
		if(!jz.equals(new BigDecimal("-999"))){
			if(sub.compareTo(jz) == 1){
				sub = jz;
			}
		}
		
		//2、公式计算结果为正数是增量，计算结果为负数是扣量
		if(sub.signum() == -1){
			//扣量比
			BigDecimal klb = getDeductionsValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊扣量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}else{
			//增量比
			BigDecimal zlb = getIncrementValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊增量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(zlb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	
	
	
	/**
	 * 稻谷杂质计算
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 杂质公式：
	 * 	增扣量百分比＝（标准值－检验值）/系数＊增扣量比
	 * 约束：
	 * 	1、标准值－检验值﹤1，不计增扣量和增扣价。
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量
	 * 	3、矿物质含量超标的，加扣量0.75%，低于标准规定的，不增量。 （暂未矿物质含量）
	 */
	public static Map<String, Object> getPaddyImpurityMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		} 
		
		//2、公式计算结果为正数是增量，计算结果为负数是扣量
		if(sub.signum() == -1){
			//扣量比
			BigDecimal klb = getDeductionsValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊扣量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}else{
			//增量比
			BigDecimal zlb = getIncrementValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊增量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(zlb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
	}
	
	
	/**
	 * 稻谷整精米率计算
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 整精米率公式：
	 * 	扣量百分比＝（标准值－检验值）/系数＊扣量比
	 * 约束：
	 * 	1、标准值－检验值﹤1，不计扣量。
	 * 	2、无增量。
	 * 	3、含量超过38%的，不得收购
	 * 
	 */
	public static Map<String, Object> getPaddyHeadRiceRateMap(Map<String, Object> amountMap,BigDecimal standardValue,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//标准值
		BigDecimal bzz = standardValue;
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//高于标准规定的不增量
		if(jyz.compareTo(bzz) == 1){
			resultMap = getMapInstance();
			resultMap.put("amount", 0);
			resultMap.put("price", 0);
			return resultMap;
		}
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//拒收下线
		BigDecimal jsxx = getExtremeValue(amountMap);
		
		if(!jsxx.equals(new BigDecimal("-999"))){
			//含量超过38%的，不得收购
			if(checkValue.compareTo(jsxx) == -1 || checkValue.compareTo(jsxx) == 0){
				throw new Exception("含量未超过"+jsxx.setScale(2, BigDecimal.ROUND_HALF_UP)+"%的，不得收购");
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//扣量比
		BigDecimal klb = getDeductionsValue(amountMap);
		//增扣量百分比＝（标准值－检验值）/系数＊扣量比 注： 不完善粒没有增量
		zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl.negate());
		resultMap.put("price", zkj);
		
		return resultMap;
	}
	
	
	/**
	 * 稻谷互混率
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param standardValue
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 互混率公式：
	 * 	扣量百分比＝（标准值－检验值）/系数＊扣量比
	 */
	public static Map<String, Object> getPaddyMutualMixingRatioMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//扣量比
		BigDecimal klb = getDeductionsValue(amountMap);
		//增扣量百分比＝（标准值－检验值）/系数＊扣量比 注： 不完善粒没有增量
		zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	
	
	/**
	 * 稻谷黄粒米计算
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description :
	 * 公式：
	 * 	扣量百分比＝（标准值－检验值）/系数＊扣量比
	 * 约束：
	 * 	1、标准值－检验值﹤1，不计扣量。
	 * 	2、无增量。
	 */
	public static Map<String, Object> getPaddyYellowColoredRiceMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		BigDecimal jssx = getUpperLimitValue(amountMap);
		
		if(!jssx.equals(new BigDecimal("-999"))){
			if(sub.compareTo(jssx) == 1){
				throw new Exception("最高不得大于" + getUpperLimitValue(amountMap) + "%");
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//扣量比
		BigDecimal klb = getDeductionsValue(amountMap);
		//增扣量百分比＝（标准值－检验值）/系数＊扣量比 注： 不完善粒没有增量
		zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
	}
	
	
	/**
	 * 小麦的水分计算
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 水分公式：
	 * 	增扣量百分比＝（标准值－检验值）/系数＊增扣量比
	 * 水分约束：
	 * 	1、|标准值－检验值|﹤0.5，不计增扣量和增扣价。
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量。
	 * 
	 */
	public static Map<String, Object> getWheatMoistureMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap);
		
		//极值
		BigDecimal jz = getIgnoredValue(amountMap);
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//标准值－检验值﹥极值时，不再增量；
		if(!jz.equals(new BigDecimal("-999"))){
			if(sub.compareTo(jz) == 1){
				sub = jz;
			}
		}
		
		
		//2、公式计算结果为正数是增量，计算结果为负数是扣量
		if(sub.signum() == -1){
			//扣量比
			BigDecimal klb = getDeductionsValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊扣量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}else{
			//增量比
			BigDecimal zlb = getIncrementValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊增量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(zlb).setScale(2, BigDecimal.ROUND_HALF_UP);
		} 
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	
	
	
	/**
	 * 小麦的杂质计算
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 杂质公式：
	 * 	增扣量百分比＝（标准值－检验值）/系数＊增扣量比
	 * 杂质约束：
	 * 	1、标准值－检验值﹤0.5，不计增扣量和增扣价。
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量
	 * 	3、矿物质含量超标的，加扣量0.75%，低于标准规定的，不增量。 
	 * 
	 */
	public static Map<String, Object> getWheatImpurityMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap);
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		} 
		
		//2、公式计算结果为正数是增量，计算结果为负数是扣量
		if(sub.signum() == -1){
			//扣量比
			BigDecimal klb = getDeductionsValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊扣量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}else{
			//增量比
			BigDecimal zlb = getIncrementValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊增量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(zlb).setScale(2, BigDecimal.ROUND_HALF_UP);
		} 
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	
	
	/**
	 * 小麦杂质无机物计算
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-22 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 约束：
	 * 	矿物质含量超标的，加扣量0.75%，低于标准规定的，不增量。
	 */
	public static Map<String, Object>  getWheatMineralMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception {
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//扣量比
		BigDecimal klb = new BigDecimal("0");
		
		//如果没有输入扣量比
		try{
			klb = getDeductionsValue(amountMap);
		}catch (Exception e) {
			resultMap = getMapInstance();
			resultMap.put("amount", 0);
			resultMap.put("price", 0);
			return resultMap;
		}
		
		//矿物质含量超标的，加扣量0.75% （含量超过标准值）
		if(checkValue.compareTo(bzz) == 1){
			resultMap = getMapInstance();
			resultMap.put("amount",klb.setScale(2, BigDecimal.ROUND_HALF_UP).negate());
			resultMap.put("price", 0);
			return resultMap;
		}
		
		//低于标准不计算增量
		resultMap = getMapInstance();
		resultMap.put("amount",0);
		resultMap.put("price", 0);
		
		return resultMap;
		
	}
	
	/**
	 * 小麦的不完善粒
	 * All rights Reserved, Designed By RDA 
	 * @create 2016-11-23 by wangkexin
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param standardValue
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 	不完善粒公式：
	 * 		扣量百分比＝（标准值－检验值）/系数＊扣量比
	 * 	约束：
	 * 		1、标准值－检验值﹤1，不计扣量。
	 * 		2、无增量。
	 */
	public static Map<String, Object> getWheatUnsoundGrainMap(Map<String, Object> amountMap,BigDecimal standardValue,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//标准值
		BigDecimal bzz = standardValue;
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
//			throw new Exception("增扣量系数为零");
			resultMap = getMapInstance();
			resultMap.put("amount",0);
			resultMap.put("price", 0);
			return resultMap;
		}
		
		//扣量比
		BigDecimal klb = getDeductionsValue(amountMap);
		//增扣量百分比＝（标准值－检验值）/系数＊扣量比 注： 不完善粒没有增量
		zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
	}

	/**
	 * 获取大米及小麦粉的水分增扣量
	 * All rights Reserved, Designed By RDA 
	 * @create 2020-07-16 by dengwb
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 水分公式：
	 * 	增扣量百分比＝（标准值－检验值）/系数＊增扣量比
	 * 约束：
	 * 	1、|标准值－检验值|﹤0.5，不计增扣量和增扣价。
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量
	 */
	public static Map<String, Object> getRiceMoistureMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception {
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap);
		
		//极值
		BigDecimal jz = getIgnoredValue(amountMap);
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//3、标准值－检验值﹥极值时，不再增量；
		if(!jz.equals(new BigDecimal("-999"))){
			if(sub.compareTo(jz) == 1){
				sub = jz;
			}
		}
		
		//2、公式计算结果为正数是增量，计算结果为负数是扣量
		if(sub.signum() == -1){
			//扣量比
			BigDecimal klb = getDeductionsValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊扣量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}else{
			//增量比
			BigDecimal zlb = getIncrementValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊增量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(zlb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	
	/**
	 * 大米的杂质计算
	 * All rights Reserved, Designed By RDA 
	 * @create 2020-07-16 by dengwb
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 杂质公式：
	 * 	增扣量百分比＝（标准值－检验值）/系数＊增扣量比
	 * 杂质约束：
	 * 	1、标准值－检验值﹤0.5，不计增扣量和增扣价。
	 * 	2、公式计算结果为正数是增量，计算结果为负数是扣量
	 * 	3、矿物质含量超标的，加扣量0.75%，低于标准规定的，不增量。 
	 * 
	 */
	public static Map<String, Object> getRiceImpurityMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap);
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		} 
		
		//2、公式计算结果为正数是增量，计算结果为负数是扣量
		if(sub.signum() == -1){
			//扣量比
			BigDecimal klb = getDeductionsValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊扣量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		}else{
			//增量比
			BigDecimal zlb = getIncrementValue(amountMap);
			//增扣量百分比＝（标准值－检验值）/系数＊增量比
			zkl = sub.divideAndRemainder(amountRatio)[0].multiply(zlb).setScale(2, BigDecimal.ROUND_HALF_UP);
		} 
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	
	/**
	 * 小麦的不完善粒
	 * All rights Reserved, Designed By RDA 
	 * @create 2020-07-16 by dengwb
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param standardValue
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 	不完善粒公式：
	 * 		扣量百分比＝（标准值－检验值）/系数＊扣量比
	 * 	约束：
	 * 		1、标准值－检验值﹤1，不计扣量。
	 * 		2、无增量。
	 */
	public static Map<String, Object> getRiceUnsoundGrainMap(Map<String, Object> amountMap,BigDecimal standardValue,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//标准值
		BigDecimal bzz = standardValue;
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//扣量比
		BigDecimal klb = getDeductionsValue(amountMap);
		//增扣量百分比＝（标准值－检验值）/系数＊扣量比 注： 不完善粒没有增量
		zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
	}
	
	/**
	 * 稻谷互混率
	 * All rights Reserved, Designed By RDA 
	 * @create 2020-07-16 by dengwb
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param standardValue
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description ：
	 * 互混率公式：
	 * 	扣量百分比＝（标准值－检验值）/系数＊扣量比
	 */
	public static Map<String, Object> getRiceMutualMixingRatioMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//扣量比
		BigDecimal klb = getDeductionsValue(amountMap);
		//增扣量百分比＝（标准值－检验值）/系数＊扣量比 注： 不完善粒没有增量
		zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
		
	}
	
	/**
	 * 稻谷黄粒米计算
	 * All rights Reserved, Designed By RDA 
	 * @create 2020-07-16 by dengwb
	 * @update 修改时间   by 修改人
	 * @param amountMap
	 * @param checkValue
	 * @throws Exception
	 * @return Map<String,Object>
	 * @description :
	 * 公式：
	 * 	扣量百分比＝（标准值－检验值）/系数＊扣量比
	 * 约束：
	 * 	1、标准值－检验值﹤1，不计扣量。
	 * 	2、无增量。
	 */
	public static Map<String, Object> getRiceYellowColoredRiceMap(Map<String, Object> amountMap,BigDecimal checkValue) throws Exception{
		
		Map<String, Object> resultMap = null;
		
		//标准值
		BigDecimal bzz = getStandardValue(amountMap);
		
		//检验值
		BigDecimal jyz = checkValue;
		
		//不计扣量值
		BigDecimal bjkl = getNoCalculationValue(amountMap); 
		
		//标准值－检验值
		BigDecimal sub = bzz.subtract(jyz);
		
		//标准值－检验值的绝对值
		BigDecimal subAbs = sub.abs();
		
		//增扣量百分比
		BigDecimal zkl = new BigDecimal("0");
		
		//增扣价百分比
		BigDecimal zkj = new BigDecimal("0");
		
		//1、|标准值－检验值|﹤ 不计扣量值，不计增扣量和增扣价,增扣量和增扣价为0；
		if(!bjkl.equals(new BigDecimal("-999"))){
			if(subAbs.compareTo(bjkl) == -1){
				resultMap = getMapInstance();
				resultMap.put("amount", 0);
				resultMap.put("price", 0);
				return resultMap;
			}
		}
		
		BigDecimal jssx = getUpperLimitValue(amountMap);
		
		if(!jssx.equals(new BigDecimal("-999"))){
			if(sub.compareTo(jssx) == 1){
				throw new Exception("最高不得大于" + getUpperLimitValue(amountMap) + "%");
			}
		}
		
		//获取增扣量系数
		BigDecimal amountRatio = getAmountRatioValue(amountMap);
		
		if(amountRatio.compareTo(new BigDecimal("0")) == 0){
			throw new Exception("增扣量系数为零");
		}
		
		//扣量比
		BigDecimal klb = getDeductionsValue(amountMap);
		//增扣量百分比＝（标准值－检验值）/系数＊扣量比 注： 不完善粒没有增量
		zkl = sub.divideAndRemainder(amountRatio)[0].multiply(klb).setScale(2, BigDecimal.ROUND_HALF_UP);
		
		resultMap = getMapInstance();
		resultMap.put("amount", zkl);
		resultMap.put("price", zkj);
		
		return resultMap;
	}
}
