package com.hx.phip.tool.refund;

import com.hx.common.service.CommonService;
import com.hx.exception.TipsException;
import com.hx.mybatisTool.SqlSentence;
import com.hx.phiappt.common.OrderItemConstants;
import com.hx.phiappt.common.RefundStatus;
import com.hx.phiappt.model.BaseEntity;
import com.hx.phiappt.model.cardItem.CardEquity;
import com.hx.phiappt.model.cardItem.CardItem;
import com.hx.phiappt.model.cardItem.CardItemInfo;
import com.hx.phiappt.model.order.OrderItem;
import com.hx.phiappt.model.refund.RefundRecordConsumePay;
import com.hx.phiappt.model.refund.RefundRecordItem;
import com.hx.phiappt.model.refund.RefundRecordItemSource;
import com.hx.phiappt.model.user.UserCard;
import com.hx.phip.dao.mapper.*;
import com.hx.phip.tool.user.UserCardTool;
import com.hx.phip.vo.order.payment.PayMethodVo;
import com.hx.phip.vo.order.refund.DistributionRedundVo;
import com.hx.phip.vo.order.refund.RefundCardVo;
import com.hx.phip.vo.user.UserCardItemInfoVo;
import com.hx.util.StringUtils;
import com.hz.his.vo.order.refund.RefundUserCardItemVo;
import com.hz.his.vo.order.refund.RefundUserCardVo;
import com.platform.exception.PlatTipsException;
import com.platform.resultTool.PlatformCode;
import org.springframework.beans.BeanUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class RefundTool {

    /**获取已退款方式金额，根据支付方式编号求和返回
     * 注意：groupByONumberNo和groupByConsumePayId不能同时使用
     * @param itemId 订单子单标识
     * @param refundRecordItemId 退款子单标识
     * @param groupByONumberNo 根据支付方式编号求和
     * @param groupByConsumePayId 根据支付方式记录标识求和
     * @param commonService 映射
     * @return 返回已退款方式金额集合
     */
    public static List<RefundRecordConsumePay> getRefundRecordConsumePay(String itemId, String refundRecordItemId, boolean groupByONumberNo
            , boolean groupByConsumePayId, CommonService commonService){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        sql.append("SELECT");
        if(groupByONumberNo){
            sql.append(" a.numberNo,");
        }
        if(groupByConsumePayId){
            sql.append(" a.consumePayId,");
        }
        sql.append("SUM(a.refundTotal) AS refundTotal FROM refund_record_consume_pay a");
        sql.append(" JOIN refund_record rr ON rr.id = a.refundRecordId AND rr.isDel = 0 AND rr.refundStatus = #{m.refundStatus}");
        sql.append("  WHERE a.isDel = 0");
        if(StringUtils.noNull(itemId)){
            sql.append("  AND a.commonId = #{m.commonId}");
        }
        if(StringUtils.noNull(refundRecordItemId)){
            sql.append("  AND a.refundRecordItemId = #{m.refundRecordItemId}");
        }
        if(groupByONumberNo){
            sql.append(" GROUP BY a.numberNo");
        }
        if(groupByConsumePayId){
            sql.append(" GROUP BY a.consumePayId");
        }
        //获取已退款的支付方式
        values.put("commonId",itemId);
        values.put("refundStatus", RefundStatus.STATUS_SUCC_REFUND);
        sqlSentence.sqlSentence(sql.toString(),values);
        return commonService.selectList(RefundRecordConsumePayMapper.class,sqlSentence);
    }

    /**获取一级退款子单已退金额
     * 主要查询，单个数量分配的退款金额，因为目前是按照数量来分配金额退款的
     * @param orderItemId 一级退款子单关联标识
     * @param goodsType 商品类型
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundRecordItem getOneAlreadyRefundTotal(String orderItemId,String goodsType, CommonService commonService ){

        //查找正常退款的
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();
        //获取已退款的金额，剔除掉用户卡项的部分退
        values.put("orderItemId",orderItemId);
        sql.append("SELECT ROUND(SUM(rri.occupyRefundTotal),2) AS occupyRefundTotal,ROUND(SUM(rri.occupyRefundIntegral),2) AS occupyRefundIntegral");
        sql.append(" FROM refund_record_item rri");
        sql.append(" JOIN refund_record rr ON rr.id = rri.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rri.isDel = 0 AND rri.orderItemId = #{m.orderItemId} AND rri.userCardId IS NULL");
        sqlSentence.sqlSentence(sql.toString(),values);
        RefundRecordItem refundRecordItem = commonService.selectOne(RefundRecordItemMapper.class,sqlSentence);
        if(refundRecordItem == null){
            //设置没有找到
            refundRecordItem.setIsDel(BaseEntity.YES);
            refundRecordItem = new RefundRecordItem();
        }

        //用户卡包退款，系统退款总金额，按照退款数量来算的，用户卡包部分退，要特殊查找
        if(OrderItemConstants.TYPE_CARD.equals(goodsType)){
            //查找有没有这个卡包部分退款的记录
            List<RefundRecordItem> refundRecordItemList = findRefundUserCard(orderItemId,null,commonService);
            if(refundRecordItemList.size() > 0){
                refundRecordItem.setIsDel(BaseEntity.NO);
            }
            for(RefundRecordItem refundRecordItem1:refundRecordItemList){
                refundRecordItem.setOccupyRefundTotal(refundRecordItem.getOccupyRefundTotal().add(refundRecordItem1.getOccupyRefundTotal()));
                refundRecordItem.setOccupyRefundIntegral(refundRecordItem.getOccupyRefundIntegral().add(refundRecordItem1.getOccupyRefundIntegral()));
            }
        }

        return refundRecordItem;
    }

    /**获取二级退款子单已退金额
     * @param orderItemSonId 二级退款子单关联标识/关联卡项条目的id
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundRecordItemSource getTwoAlreadyRefundTotal(String orderItemSonId, CommonService commonService ){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        values.put("orderItemSonId",orderItemSonId);
        sql.append("SELECT ROUND(SUM(rris.occupyRefundTotal),2) AS occupyRefundTotal,ROUND(SUM(rris.occupyRefundIntegral),2) AS occupyRefundIntegral");
        sql.append(" FROM refund_record_item_source rris");
        sql.append(" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rris.isDel = 0 AND rris.orderItemSonId = #{m.orderItemSonId}");
        //获取已退款的金额
        sqlSentence.sqlSentence(sql.toString(),values);
        RefundRecordItemSource refundRecordItemSource = commonService.selectOne(RefundRecordItemSourceMapper.class,sqlSentence);

        if(refundRecordItemSource == null){
            //设置是没有找到
            refundRecordItemSource.setIsDel(BaseEntity.YES);
            return new RefundRecordItemSource();
        }else{
            return refundRecordItemSource;
        }
    }

    /**计算用户卡包条目退款金额*/
    public static void userCardRefundCount(UserCard userCard,RefundUserCardVo refundUserCardVo, CommonService commonService, RefundMapper refundMapper){

        ////算出金额：
        //1、算出该卡可退总金额
        //2、算出卡项条目总金额，就是占订单支付金额的钱
        //3、算出单条目的权益占用金额
        //4、获取该条目已退款金额
        //5、算出“单次抵扣金额”，再乘以数量得出“抵扣总金额”
        //6、用“抵扣总金额”算出占用整个卡项总金额的“比例”
        //7、比较金额，得出可退金额，注意最后一次要全部退掉

        //获取卡项
        CardItem cardItem = commonService.selectOneByKey(CardItemMapper.class,userCard.getCardItemId());
        if(cardItem == null){
            throw new TipsException("获取卡项信息失败[210]！");
        }

        //获取子单
        OrderItem orderItem = commonService.selectOneByKey(OrderItemMapper.class,userCard.getSourceId());
        if(orderItem == null){
            throw new TipsException("获取订单子单失败[210]！");
        }

        //公用对象
        RefundRecordItemSource itemSource;

        //用户卡项分配可退总金额
        RefundCardVo refundCard = new RefundCardVo();

        CardItemInfo cardItemInfo;
        CardEquity cardEquity;
        //条目金额计算
        BigDecimal sumCardBagMoney;
        //条目积分计算
        BigDecimal sumCardBagIntegral;

        //获取卡项的权益数量
        int cardEquityNum = UserCardTool.getCardEquityCount(userCard.getCardItemId(),commonService);

        //存储权益分配的退款金额
        Map<String,RefundCardVo> cardEquityMap = new HashMap<>();

        //比例
        RefundCardVo refundCardEquity;
        RefundCardVo refundCardInfo;
        BigDecimal proportion;
        for(RefundUserCardItemVo refundUserCardItemVo:refundUserCardVo.getRefundUserCardItemVoList()){
            if(StringUtils.isEmpty(refundUserCardItemVo.getCardItemInfoId())){
                throw new TipsException("卡项条目标识必传[210]！");
            }
            if(refundUserCardItemVo.getRefundQuantity() == null || refundUserCardItemVo.getRefundQuantity() < 1){
                throw new TipsException("卡项条目退款次数必填[210]！");
            }
            cardItemInfo = commonService.selectOneByKey(CardItemInfoMapper.class,refundUserCardItemVo.getCardItemInfoId());
            if(cardItemInfo == null){
                throw new TipsException("获取卡项条目信息失败[210]！");
            }
            cardEquity = commonService.selectOneByKey(CardEquityMapper.class,cardItemInfo.getCardEquityId());
            if(cardEquity == null){
                throw new TipsException("获取卡项权益信息失败[210]！");
            }
            //-----校验
            //获取可用剩余使用次数
            UserCardItemInfoVo uerCardItemInfoVo = UserCardTool.getSurplusNumber(userCard,cardItemInfo,cardEquity,commonService);
            //获取当前需要抵扣的次数
            Integer usedNum = UserCardTool.countUsedNumber(refundUserCardItemVo.getRefundQuantity(),cardItemInfo,cardEquity);
            if(!uerCardItemInfoVo.isNumByNum()){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"卡项退款提示:不符合N选M规则,请重试");
            }
            if(uerCardItemInfoVo.getSurplusNum() <= 0 ||usedNum > uerCardItemInfoVo.getSurplusNum()){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"卡项退款提示:卡项的【"+cardItemInfo.getCommonName()+"】次数不够");
            }

            refundCardInfo = new RefundCardVo();

            //-----算出权益分配到金额
            //查看权益是否已经分配好了的
            refundCardEquity = getCardEquityData(orderItem,userCard,cardItem,cardEquity,refundCard,cardEquityNum,cardEquityMap,commonService,refundMapper);
            //判断是不是最后一个条目
            if(CardEquity.EQUITY_TYPE_TIME_CARD.equals(cardEquity.getEquityType())){
                //次卡，权益有总次数，所有条目使用的总次数不能大于权益的总次数
                //判断数量
                if(uerCardItemInfoVo.getSurplusNum() < refundUserCardItemVo.getRefundQuantity()){
                    //最后的次数
                    refundCardInfo.setOccupyRefundTotal(refundCardEquity.getSurplusTotal());
                    refundCardInfo.setOccupyRefundIntegral(refundCardEquity.getSurplusIntegral());
                }else{

                }
                refundCardInfo.setSurplusTotal(refundCardEquity.getSurplusTotal());
                refundCardInfo.setSurplusIntegral(refundCardEquity.getSurplusIntegral());
            }else if(CardEquity.EQUITY_TYPE_N_M.equals(cardEquity.getEquityType())){
                //判断条目数量，再判断数量


            }else{
                //固定或者其他
                userCardItemInfoVo.setSurplusNum(cardItemInfo.getMaxNum() - cardItemInfoUseMap.computeIfAbsent(cardItemInfo.getId(),k->0));
            }

            //-----算出单次划扣金额
            //获取单次价格金额
            sumCardBagMoney = UserCardTool.countOneMoney(cardItemInfo);
            //计算抵扣总的分摊明细
            sumCardBagMoney = sumCardBagMoney.multiply(BigDecimal.valueOf(refundUserCardItemVo.getRefundQuantity()).setScale(2,RoundingMode.DOWN));
            //算比例
            if(cardItem.getTotal() != null && cardItem.getTotal().compareTo(BigDecimal.ZERO) > 0){
                proportion = sumCardBagMoney.divide(cardItem.getTotal(),20,RoundingMode.HALF_UP);
            }else{
                proportion = BigDecimal.ZERO;
            }

            //算出占用购买卡项订单时候金额（分摊模式）
            sumCardBagMoney = occupyRefundTotal.multiply(proportion);
            sumCardBagIntegral = occupyRefundIntegral.multiply(proportion);

            //获取卡项条目已退款金额
            refundRecordItemSource = getTwoAlreadyRefundTotal(cardItemInfo.getId(),null,null,commonService);

            //

            //不能超过卡项条目的分摊总金额

        }

    }

    /**查找部分退款的用户卡包信息，根据用户卡包标识去重了
     * @param orderItemId 子单标识
     * @param userCardId 用户卡包标识
     * @param commonService 映射
     */
    public static List<RefundRecordItem> findRefundUserCard(String orderItemId,String userCardId,CommonService commonService){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();

        StringBuilder sql = new StringBuilder();

        //--------获取用户卡包的总金额
        //查找有没有这个卡包部分退款的记录
        sql.append("SELECT rri.occupyRefundTotal,rri.occupyRefundIntegral,rri.userCardId FROM refund_record_item rri");
        sql.append(" JOIN refund_record rr ON rr.id = rri.refundRecordId");
        sql.append(" JOIN user_card uc ON uc.id = rri.userCardId");
        sql.append(" AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rri.isDel = 0");
        if(StringUtils.noNull(orderItemId)){
            values.put("orderItemId",orderItemId);
            sql.append(" AND rri.orderItemId = #{m.orderItemId}");
        }
        if(StringUtils.noNull(userCardId)){
            values.put("userCardId",userCardId);
            sql.append(" AND rri.userCardId = #{m.userCardId}");
        }else{
            sql.append(" AND rri.userCardId IS NOT NULL");
        }
        sql.append(" GROUP BY rri.userCardId");

        sqlSentence.sqlSentence(sql.toString(),values);
        return commonService.selectList(UserCardMapper.class,sqlSentence);
    }

    /**获取卡包已分配的金额（权益分配的金额）
     * @param userCardId 用户卡项标识，主要获取用户卡项分配的金额
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundRecordItemSource getCardRealRefund(String userCardId, CommonService commonService ){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        values.put("userCardId",userCardId);
        sql.append("SELECT rris.occupyEqRefundTotal,rris.occupyEqRefundIntegral");
        sql.append(" FROM refund_record_item_source rris");
        sql.append(" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rris.isDel = 0 AND rris.userCardId = #{m.userCardId} GROUP BY rris.cardEquityId");

        List<RefundRecordItemSource> refundRecordItemSourceList = commonService.selectList(RefundRecordItemSourceMapper.class,sqlSentence);

        RefundRecordItemSource source = new RefundRecordItemSource();
        if(refundRecordItemSourceList.size()==0){
            source.setIsDel(BaseEntity.YES);
            return source;
        }
        for(RefundRecordItemSource refundRecordItemSource:refundRecordItemSourceList){
            //计算有多少个权益参与了退款
            refundRecordItemSource.setRealRefundNum(refundRecordItemSource.getRealRefundNum()+1);
            source.setOccupyRefundTotal(source.getOccupyRefundTotal().add(refundRecordItemSource.getOccupyEqRefundTotal()));
            source.setOccupyRefundIntegral(source.getOccupyRefundIntegral().add(refundRecordItemSource.getOccupyEqRefundIntegral()));
        }
        return source;
    }

    /**获取卡包权益已退款金额（条目分配的金额）
     * @param cardEquityId 卡项权益标识，主要获取卡项权益分配的金额
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundRecordItemSource getCardEquityRealRefund(String cardEquityId, CommonService commonService ){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        values.put("cardEquityId",cardEquityId);
        sql.append("SELECT rris.occupyItemRefundTotal,rris.occupyItemRefundIntegral,rris.occupyEqRefundTotal,rris.occupyEqRefundIntegral");
        sql.append(" FROM refund_record_item_source rris");
        sql.append(" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rris.isDel = 0 AND rris.cardEquityId = #{m.cardEquityId} GROUP BY orderItemSonId");

        List<RefundRecordItemSource> refundRecordItemSourceList = commonService.selectList(RefundRecordItemSourceMapper.class,sqlSentence);

        RefundRecordItemSource source = new RefundRecordItemSource();
        if(refundRecordItemSourceList.size()==0){
            source.setIsDel(BaseEntity.YES);
            return source;
        }
        for(RefundRecordItemSource refundRecordItemSource:refundRecordItemSourceList){
            //计算有多少个条目参与了退款
            source.setRealRefundNum(refundRecordItemSource.getRealRefundNum()+1);
            source.setRefundMoney(source.getRefundMoney().add(refundRecordItemSource.getOccupyItemRefundTotal()));
            source.setRefundIntegral(source.getRefundIntegral().add(refundRecordItemSource.getOccupyItemRefundIntegral()));
            source.setOccupyEqRefundTotal(refundRecordItemSource.getOccupyEqRefundTotal());
            source.setOccupyEqRefundIntegral(refundRecordItemSource.getOccupyEqRefundIntegral());
        }
        return source;
    }

    /**获取卡包条目已退款金额（条目分配的金额）
     * @param cardInfoId 卡项条目标识，主要获取卡项条目分配的金额
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundCardVo getCardInfoData(String cardInfoId,CommonService commonService){

        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        values.put("orderItemSonId",cardInfoId);
        sql.append("SELECT SUM(rris.occupyRefundTotal) AS occupyRefundTotal,SUM(rris.occupyRefundIntegral) AS occupyRefundIntegral");
        sql.append(",SUM(rris.realRefundNum) AS realRefundNum,rris.occupyItemRefundTotal,rris.occupyItemRefundIntegral");
        sql.append(" FROM refund_record_item_source rris");
        sql.append(" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rris.isDel = 0 AND rris.orderItemSonId = #{m.orderItemSonId} GROUP BY orderItemSonId");

        RefundRecordItemSource itemSource = commonService.selectOne(RefundRecordItemSourceMapper.class,sqlSentence);

        RefundCardVo refundCardInfo = new RefundCardVo();

        if(itemSource != null){
            refundCardInfo.setJoinRefund(true);
            refundCardInfo.setRefundNum(itemSource.getRealRefundNum());
            refundCardInfo.setOccupyRefundTotal(itemSource.getOccupyItemRefundTotal());
            refundCardInfo.setOccupyRefundIntegral(itemSource.getOccupyItemRefundIntegral());
            refundCardInfo.setSurplusTotal(itemSource.getOccupyItemRefundTotal().subtract(itemSource.getOccupyRefundTotal()));
            refundCardInfo.setSurplusIntegral(itemSource.getOccupyItemRefundIntegral().subtract(itemSource.getOccupyRefundIntegral()));

        }
        return refundCardInfo;


    }


    /**获取用户卡项的参数，分配金额和剩余可退金额*/
    public static RefundCardVo getUserCardData(OrderItem orderItem,UserCard userCard,CommonService commonService,RefundMapper refundMapper){

        RefundCardVo refundCard = new RefundCardVo();
        //--------获取用户卡包分配的的可退款总金额（包含已经部分退的金额在里面）
        //查找有没有这个卡包部分退款的记录
        List<RefundRecordItem> refundRecordItemList = findRefundUserCard(orderItem.getId(),userCard.getId(),commonService);
        if(refundRecordItemList.size() == 0){
            //用户卡包没有分配总金额，那么就按照正常的流程获取可退款金额
            DistributionRedundVo distributionRedundVo = UserCardTool.userCardPay(userCard,orderItem,commonService,refundMapper);
            refundCard.setOccupyRefundTotal(distributionRedundVo.getRefundTotal());
            refundCard.setOccupyRefundIntegral(distributionRedundVo.getRefundIntegral());
        }else{
            refundCard.setJoinRefund(true);
            RefundRecordItem refundRecordItem = refundRecordItemList.get(0);
            refundCard.setOccupyRefundTotal(refundRecordItem.getOccupyRefundTotal());
            refundCard.setOccupyRefundIntegral(refundRecordItem.getOccupyRefundIntegral());
        }

        //-----计算剩余可分配给权益退款的金额
        //查找该卡包已部分退款的金额
        RefundRecordItemSource itemSource = getCardRealRefund(userCard.getId(),commonService);
        //计算该用户卡包剩余可退金额和积分，就是可分配给权益退款的金额
        refundCard.setSurplusTotal(refundCard.getOccupyRefundTotal().subtract(itemSource.getOccupyRefundTotal()));
        refundCard.setSurplusIntegral(refundCard.getOccupyRefundIntegral().subtract(itemSource.getOccupyRefundIntegral()));
        refundCard.setRefundNum(itemSource.getRealRefundNum());

        return refundCard;
    }

    /**获取用户卡项权益的参数，分配金额和剩余可退金额*/
    public static RefundCardVo getCardEquityData(OrderItem orderItem,UserCard userCard,CardItem cardItem,CardEquity cardEquity,RefundCardVo refundCard,int cardEquityNum
            ,Map<String,RefundCardVo> cardEquityMap,CommonService commonService,RefundMapper refundMapper){

        //-----算出权益分配到金额
        //查看权益是否已经分配好了的
        BigDecimal proportion;
        RefundCardVo refundCardEquity = cardEquityMap.get(cardEquity.getId());
        if(refundCardEquity == null){
            refundCardEquity = new RefundCardVo();

            //获取卡项权益已退款金额和分配的金额
            RefundRecordItemSource cardEquityRealRefund = getCardEquityRealRefund(cardEquity.getId(),commonService);
            if(cardEquityRealRefund.getIsDel().equals(BaseEntity.YES)){
                //没有找到已经分配好的，进行新的分配
                //获取用户卡包分配金额
                if(!refundCard.isJoinRefund()){
                    BeanUtils.copyProperties(getUserCardData(orderItem,userCard,commonService,refundMapper),refundCard);
                    refundCard.setJoinRefund(true);
                }

                if(cardEquityNum>=refundCard.getRefundNum()+1){
                    //是最后一个
                    refundCardEquity.setOccupyRefundTotal(refundCard.getSurplusTotal());
                    refundCardEquity.setOccupyRefundIntegral(refundCard.getSurplusIntegral());
                }else{
                    //不是最后一个，通过比例来算金额
                    if(cardItem.getTotal().compareTo(BigDecimal.ZERO) > 0){
                        proportion = cardEquity.getShareMoney().divide(cardItem.getTotal(),20,RoundingMode.HALF_UP);
                    }else{
                        proportion = BigDecimal.ZERO;
                    }
                    refundCardEquity.setOccupyRefundTotal(refundCard.getOccupyRefundTotal().multiply(proportion).setScale(2,RoundingMode.HALF_UP));
                    refundCardEquity.setOccupyRefundIntegral(refundCard.getOccupyRefundIntegral().multiply(proportion).setScale(2,RoundingMode.HALF_UP));

                    //判断不能大于权益设置的金额
                    if(refundCardEquity.getOccupyRefundTotal().compareTo(cardEquity.getShareMoney()) > 0){
                        refundCardEquity.setOccupyRefundTotal(cardEquity.getShareMoney());
                    }
                    //判断不能大于剩下的可退金额
                    if(refundCardEquity.getOccupyRefundTotal().compareTo(refundCard.getSurplusTotal()) > 0){
                        refundCardEquity.setOccupyRefundTotal(refundCard.getSurplusTotal());
                    }
                    //判断不能大于剩下的可退积分
                    if(refundCardEquity.getOccupyRefundIntegral().compareTo(refundCard.getSurplusIntegral()) > 0){
                        refundCardEquity.setOccupyRefundIntegral(refundCard.getSurplusIntegral());
                    }
                }
                refundCardEquity.setSurplusTotal(refundCardEquity.getOccupyRefundTotal());
                refundCardEquity.setSurplusIntegral(refundCardEquity.getOccupyRefundIntegral());
            }else{
                refundCardEquity.setJoinRefund(true);
                refundCardEquity.setRefundNum(cardEquityRealRefund.getRealRefundNum());
                refundCardEquity.setOccupyRefundTotal(cardEquityRealRefund.getOccupyEqRefundTotal());
                refundCardEquity.setOccupyRefundIntegral(cardEquityRealRefund.getOccupyEqRefundIntegral());
                refundCardEquity.setSurplusTotal(cardEquityRealRefund.getOccupyEqRefundTotal().subtract(cardEquityRealRefund.getRefundMoney()));
                refundCardEquity.setSurplusIntegral(cardEquityRealRefund.getOccupyEqRefundIntegral().subtract(cardEquityRealRefund.getRefundIntegral()));
            }
            cardEquityMap.put(cardEquity.getId(),refundCardEquity);
        }
        return refundCardEquity;
    }


}