package com.kidgrow.oprationcenter.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.kidgrow.common.constant.ConsumptionConstant;
import com.kidgrow.common.constant.PayConstants;
import com.kidgrow.common.model.PageResult;
import com.kidgrow.common.model.ResultBody;
import com.kidgrow.common.service.impl.SuperServiceImpl;
import com.kidgrow.common.utils.DateUtils;
import com.kidgrow.common.utils.StringUtils;
import com.kidgrow.oprationcenter.mapper.ConsumptionRecordMapper;
import com.kidgrow.oprationcenter.model.ConsumptionRecord;
import com.kidgrow.oprationcenter.model.PayManager;
import com.kidgrow.oprationcenter.model.ProductOrderDetail;
import com.kidgrow.oprationcenter.model.SaasClientPay;
import com.kidgrow.oprationcenter.service.IConsumptionRecordService;
import com.kidgrow.oprationcenter.service.IPayManagerService;
import com.kidgrow.oprationcenter.service.IProductOrderDetailService;
import com.kidgrow.oprationcenter.service.ISaasClientPayService;
import com.kidgrow.oprationcenter.vo.ConsumptionRequest;
import com.kidgrow.oprationcenter.vo.ConsumptionVo;
import com.kidgrow.oprationcenter.vo.ProductOrderJoinDetail;
import com.kidgrow.oprationcenter.vo.UserProductDetail;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.MapUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

//import org.springframework.amqp.rabbit.annotation.RabbitListener;
//import org.springframework.amqp.rabbit.core.RabbitTemplate;

/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
 *
 * @version 1.0
 * @Description: <br>
 * @Project: 运营中心<br>
 * @CreateDate: Created in 2020-06-23 15:07:14 <br>
 * @Author: <a href="411269194@kidgrow.com">houruijun</a>
 */
@Slf4j
@Service
public class ConsumptionRecordServiceImpl extends SuperServiceImpl<ConsumptionRecordMapper, ConsumptionRecord> implements IConsumptionRecordService {
    @Autowired
    private IProductOrderDetailService productOrderDetailService;
    @Autowired
    private IPayManagerService payManagerService;
    @Autowired
    private ISaasClientPayService saasClientPayService;
    @Autowired
    private RabbitTemplate rabbitTemplate;

    private static final Logger logger = LoggerFactory.getLogger(ConsumptionRecordServiceImpl.class);
    @Value("${spring.profiles.active}")
    private String envName;

    /**
     * 列表
     *
     * @param params
     * @return
     */
    @Override
    public PageResult<ConsumptionRecord> findList(Map<String, Object> params) {
        Page<ConsumptionRecord> page = new Page<>(MapUtils.getInteger(params, "page"), MapUtils.getInteger(params, "limit"));
        List<ConsumptionRecord> list = baseMapper.findList(page, params);
        return PageResult.<ConsumptionRecord>builder().data(list).code(0).count(page.getTotal()).build();
    }

    /**
     * 列表
     *
     * @param params
     * @return
     */
    @Override
    public List<ConsumptionRecord> findAllList(Map<String, Object> params) {
        return baseMapper.findList(params);
    }

    /**
     * 根据ConsumptionRecord对象当做查询条件进行查询
     *
     * @param consumptionRecord
     * @return ConsumptionRecord
     */
    @Override
    public ConsumptionRecord findByObject(ConsumptionRecord consumptionRecord) {
        return baseMapper.findByObject(consumptionRecord);
    }

    /**
     * 要让AI读片-调用
     *
     * @param consumptionRequest 请求的数据实体
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResultBody consumptionAIStart(ConsumptionRequest consumptionRequest) {
        //默认的业务返回码
        int bcode = -1;
        //记录类型
        int recordType = ConsumptionConstant.BEFORE_DEDUCTION;
        //业务执行结果
        boolean isSuccess = true;
        //业务执行结果信息
        String reMsg = "";
        if (VateParams(consumptionRequest)) {
            //是否开通单次支付
            if (departmentIsPay(consumptionRequest)) {
                //是否支付成功
                if (departmentPayStatus(consumptionRequest)) {
                    //预扣费成功
                    reMsg = "单次支付模拟预扣费成功！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_IS_BEFORE_DEDUCTION;
                } else {
                    reMsg = "单次支付未成功，不允许预扣费！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
                    isSuccess = false;
                }
            } else {
                //先获取这个业务关联的扣费记录
                List<ConsumptionRecord> consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
                //1.先检查是否已经扣费
                if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.DEDUCTION)) {
                    //2.没有扣费，检查是否已经预扣费
                    if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.BEFORE_DEDUCTION)) {
                        //3.没有预扣，查询余额
                        Map<String, Object> vateMap = VateUserNowProduct(consumptionRequest.getConsumptionCount(), consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
                        if (Boolean.parseBoolean(vateMap.get("vateRe").toString())) {
                            //4.余额充足 获取要扣的套餐 写预扣费记录
                            if (beforeConsumption(consumptionRequest)) {
                                //预扣费成功
                                reMsg = "预扣费成功！";
                                bcode = ConsumptionConstant.BUSINESS_CODE_IS_BEFORE_DEDUCTION;
                            } else {
                                //预扣费执行失败
                                isSuccess = false;
                                reMsg = "预扣费执行失败！";
                                bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
                            }
                        } else {
                            //余额不足 或获取异常
                            isSuccess = false;
                            reMsg = vateMap.get("vateMsg").toString();
                            bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
                        }
                    } else {
                        //已经预扣费
                        reMsg = "该业务已经预扣费！";
                        bcode = ConsumptionConstant.BUSINESS_CODE_IS_BEFORE_DEDUCTION;
                    }
                } else {
                    //已经扣费
                    reMsg = "该业务已经扣费！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
                }
            }
        } else {
            isSuccess = false;
            reMsg = "传入参数有误！";
            bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
        }
        return ResultReturn(consumptionRequest, bcode, recordType, reMsg, isSuccess);
    }

    /**
     * AI返回结果-调用
     *
     * @param consumptionRequest 请求的数据实体
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResultBody consumptionAIReturn(ConsumptionRequest consumptionRequest) {
        //默认的业务返回码
        int bcode = -1;
        //记录类型
        int recordType = ConsumptionConstant.DEDUCTION;
        //业务执行结果
        boolean isSuccess = true;
        //业务执行结果信息
        String reMsg = "";
        if (VateParams(consumptionRequest)) {
            //是否开通单次支付
            if (departmentIsPay(consumptionRequest)) {
                //是否支付成功
                if (departmentPayStatus(consumptionRequest)) {
                    //预扣费成功
                    reMsg = "单次支付模拟扣费成功！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
                    //消息队列通知
                    MessageToBI(consumptionRequest);
                } else {
                    reMsg = "单次支付未成功，不允许扣费！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
                    isSuccess=false;
                }
            } else {
                //先获取这个业务关联的扣费记录
                List<ConsumptionRecord> consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
                Long hospitalId = consumptionRequest.getHospitalId();

                //1.先检查是否已经扣费
                if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.DEDUCTION)) {
                    //2.没有扣费，检查是否已经预扣费
                    if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.BEFORE_DEDUCTION)) {
                        //2.1.没有预扣，查询余额
                        Map<String, Object> vateMap = VateUserNowProduct(consumptionRequest.getConsumptionCount(), hospitalId, consumptionRequest.getDepartmentId());
                        if (Boolean.parseBoolean(vateMap.get("vateRe").toString())) {
                            //2.2.余额充足 获取要扣的套餐 写预扣费记录
                            if (beforeConsumption(consumptionRequest)) {
                                //预扣费成功
                                logger.info("医院id:【{}】AI返回结果应该不走预扣，目前确已经预扣！", hospitalId);
                            } else {
                                //预扣费执行失败
                                isSuccess = false;
                                reMsg = "预扣费执行失败！";
                                bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
                                return ResultReturn(consumptionRequest, bcode, ConsumptionConstant.BEFORE_DEDUCTION, reMsg, isSuccess);
                            }
                        } else {
                            //余额不足
                            isSuccess = false;
                            reMsg = vateMap.get("vateMsg").toString();
                            bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
                            return ResultReturn(consumptionRequest, bcode, ConsumptionConstant.BEFORE_DEDUCTION, reMsg, isSuccess);
                        }
                    }
                    if (consumptionBusiess(consumptionRequest, consumptionRecordList)) {
                        reMsg = "该业务扣费成功！";
                        bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
                    } else {
                        isSuccess = false;
                        reMsg = "该业务扣费失败！";
                        bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
                    }
                } else {
                    //已经扣费
                    reMsg = "该业务已经扣费！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
                }
            }
        } else {
            isSuccess = false;
            reMsg = "传入参数有误！";
            bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
        }
        return ResultReturn(consumptionRequest, bcode, recordType, reMsg, isSuccess);
    }

    /**
     * AI拒读/失败通知-调用
     *
     * @param consumptionRequest 请求的数据实体
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResultBody consumptionAIFail(ConsumptionRequest consumptionRequest) {
        //默认的业务返回码
        int bcode = -1;
        //记录类型
        int recordType = ConsumptionConstant.RETURN_BEFORE_DEDUCTION;
        //业务执行结果
        boolean isSuccess = false;
        //业务执行结果信息
        String reMsg = "";
        if (VateParams(consumptionRequest)) {
            //是否开通单次支付
            if (departmentIsPay(consumptionRequest)) {
                //是否支付成功
                if (departmentPayStatus(consumptionRequest)) {
                    //预扣费成功
                    reMsg = "单次支付模拟退还扣费成功！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_RETURN_DEDUCTION;
                    isSuccess=true;
                } else {
                    reMsg = "单次支付未成功，不允许退扣费！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
                }
            } else {
                //先获取这个业务关联的扣费记录
                List<ConsumptionRecord> consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
                //1.先检查是否已经扣费
                if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.DEDUCTION)) {
                    //2.没有扣费，检查是否已经预扣费
                    if (isBeforeDeduction(consumptionRecordList, ConsumptionConstant.BEFORE_DEDUCTION)) {
                        //2.1.有预扣费
                        ConsumptionRecord consumptionRecord = consumptionRecordList.stream().filter(f -> f.getRecordType() == ConsumptionConstant.BEFORE_DEDUCTION && f.getProOrderDetailId() > 0).collect(Collectors.toList()).get(0);
                        //把占用的套餐id还回去
                        Long tempProOrderDetailId = consumptionRecord.getProOrderDetailId();
                        consumptionRecord.setProOrderDetailId(0L);
                        consumptionRecord.setUpdateTime(new Date());
                        if (SaveConsumptionRecord(consumptionRecord)) {
                            //退预扣记录
                            ConsumptionRecord consumptionRecordNew = new ConsumptionRecord();
                            consumptionRecordNew.setBusinessCode(ConsumptionConstant.BUSINESS_CODE_RETURN_BEFORE_DEDUCTION);
                            consumptionRecordNew.setBusinessId(consumptionRequest.getBusinessId());
                            consumptionRecordNew.setConsumptionCount(0 - consumptionRequest.getConsumptionCount());
                            consumptionRecordNew.setRecordType(ConsumptionConstant.RETURN_BEFORE_DEDUCTION);
                            consumptionRecordNew.setProOrderDetailId(tempProOrderDetailId);
                            consumptionRecordNew.setLastRecordId(consumptionRecord.getId());
                            consumptionRecordNew.setDiaId(consumptionRequest.getDiaId());
                            if (SaveConsumptionRecord(consumptionRecordNew)) {
                                isSuccess = true;
                                reMsg = "有预扣，写退还预扣成功！";
                                bcode = ConsumptionConstant.BUSINESS_CODE_RETURN_BEFORE_DEDUCTION;
                            } else {
                                reMsg = "写退还预扣失败！";
                                bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
                            }
                        } else {
                            reMsg = "更新预扣费记录失败！";
                            bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
                        }
                    } else {
                        reMsg = "没有相关预扣记录！";
                        bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
                    }
                } else {
                    recordType = ConsumptionConstant.RETURN_DEDUCTION;
                    //3.有扣费记录 这种情况的流程，实际业务中不会出现，但理论上应该这样处理
                    //3.1 退还账户
                    //获取预扣的时候占住的套餐id
                    ConsumptionRecord consumptionRecord = consumptionRecordList.stream().filter(f -> f.getRecordType() == ConsumptionConstant.DEDUCTION).collect(Collectors.toList()).get(0);
                    if (consumptionRecord != null) {
                        ProductOrderDetail productOrderDetail = productOrderDetailService.getById(consumptionRecord.getProOrderDetailId());
                        if (productOrderDetail != null) {
                            //退还金额
                            productOrderDetail.setAilightCount(productOrderDetail.getAilightCount() + consumptionRecord.getConsumptionCount());
                            productOrderDetail.setUpdateTime(new Date());
                            //退费
                            boolean consumptionRe = productOrderDetailService.saveOrUpdate(productOrderDetail);
                            if (consumptionRe) {
                                //更新扣费记录  还回占用套餐
                                consumptionRecord.setProOrderDetailId(0L);
                                consumptionRecord.setUpdateTime(new Date());
                                if (SaveConsumptionRecord(consumptionRecord)) {
                                    //退费成功
                                    //3.2 写退费记录
                                    ConsumptionRecord consumptionRecordNew = new ConsumptionRecord();
                                    consumptionRecordNew.setBusinessCode(ConsumptionConstant.BUSINESS_CODE_RETURN_DEDUCTION);
                                    consumptionRecordNew.setBusinessId(consumptionRecord.getBusinessId());
                                    consumptionRecordNew.setConsumptionCount(0 - consumptionRecord.getConsumptionCount());
                                    consumptionRecordNew.setRecordType(ConsumptionConstant.RETURN_DEDUCTION);
                                    consumptionRecordNew.setProOrderDetailId(productOrderDetail.getId());
                                    consumptionRecordNew.setLastRecordId(consumptionRecord.getId());
                                    consumptionRecordNew.setDiaId(consumptionRequest.getDiaId());
                                    if (SaveConsumptionRecord(consumptionRecordNew)) {
                                        //写退费记录成功
                                        isSuccess = true;
                                        reMsg = "退还扣费成功！";
                                        bcode = ConsumptionConstant.BUSINESS_CODE_RETURN_DEDUCTION;
                                    } else {
                                        reMsg = "退还扣费失败！";
                                        bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
                                    }
                                } else {
                                    //更新扣费失败
                                    reMsg = "更新扣费失败！";
                                    bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
                                }
                            } else {
                                //退费失败
                                reMsg = "退还扣费失败！";
                                bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
                            }
                        } else {
                            reMsg = "无相关套餐数据！";
                            bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
                        }
                    } else {
                        reMsg = "无相关扣费数据！";
                        bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
                    }
                }
            }
        } else {
            reMsg = "传入参数有误！";
            bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
        }
        return ResultReturn(consumptionRequest, bcode, recordType, reMsg, isSuccess);
    }

    /**
     * 发起人工读片-调用
     *
     * @param consumptionRequest 请求的数据实体
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResultBody consumptionArtificial(ConsumptionRequest consumptionRequest) {
        //默认的业务返回码
        int bcode = -1;
        //记录类型
        int recordType = ConsumptionConstant.DEDUCTION;
        //业务执行结果
        boolean isSuccess = false;
        //业务执行结果信息
        String reMsg = "";
        if (VateParams(consumptionRequest)) {
            //是否开通单次支付
            if (departmentIsPay(consumptionRequest))
            {
                //是否支付成功
                if (departmentPayStatus(consumptionRequest)) {
                    //预扣费成功
                    reMsg = "单次支付模拟已经扣费成功！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
                    isSuccess = true;
                    //消息队列通知
                    MessageToBI(consumptionRequest);
                } else {
                    reMsg = "单次支付未成功，不允许业务进行！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
                }
            }
            else {
                //先获取这个业务关联的扣费记录
                List<ConsumptionRecord> consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
                //1.先检查是否已经扣费
                if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.DEDUCTION)) {
                    //2.没有扣费，检查是否已经预扣费
                    if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.BEFORE_DEDUCTION)) {
                        //3.没有预扣，查询余额
                        Map<String, Object> vateMap = VateUserNowProduct(consumptionRequest.getConsumptionCount(), consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
                        if (Boolean.parseBoolean(vateMap.get("vateRe").toString())) {
                            //4.余额充足 获取要扣的套餐 写预扣费记录
                            if (!beforeConsumption(consumptionRequest)) {
                                //预扣费执行失败
                                reMsg = "预扣费执行失败！";
                                bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
                                return ResultReturn(consumptionRequest, bcode, ConsumptionConstant.BEFORE_DEDUCTION, reMsg, isSuccess);
                            } else {
                                //发起了一个新的预扣，需要更新扣费业务数据列表
                                consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
                            }
                        } else {
                            //余额不足
                            reMsg = vateMap.get("vateMsg").toString();
                            bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
                            return ResultReturn(consumptionRequest, bcode, ConsumptionConstant.BEFORE_DEDUCTION, reMsg, isSuccess);
                        }
                    }
                    //扣费业务
                    isSuccess = consumptionBusiess(consumptionRequest, consumptionRecordList);
                    if (isSuccess) {
                        reMsg = "该业务已经扣费！";
                        bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
                    } else {
                        reMsg = "该业务扣费失败！";
                        bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
                    }
                } else {
                    isSuccess = true;
                    //已经扣费
                    reMsg = "该业务已经扣费！";
                    bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
                }
            }
        } else {
            reMsg = "传入参数有误！";
            bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
        }
        return ResultReturn(consumptionRequest, bcode, recordType, reMsg, isSuccess);
    }

    /**
     * 扣费业务(扣费 更新预扣 写扣费记录)
     *
     * @param consumptionRequest    请求参数
     * @param consumptionRecordList 扣费业务数据
     * @return
     */
    private boolean consumptionBusiess(ConsumptionRequest consumptionRequest, List<ConsumptionRecord> consumptionRecordList) {
        //3.已经预扣费 则扣费 写扣费记录 更新预扣状态
        ConsumptionRecord consumptionRecord = consumptionRecordList.stream().filter(f -> f.getRecordType() == ConsumptionConstant.BEFORE_DEDUCTION).collect(Collectors.toList()).get(0);
        Long detailId = consumptionRecord.getProOrderDetailId();
        //获取预扣的时候占住的套餐id
        ProductOrderDetail productOrderDetail = productOrderDetailService.getById(detailId);
        if (productOrderDetail.getAilightCount() >= consumptionRequest.getConsumptionCount()) {
            //扣掉
            productOrderDetail.setAilightCount(productOrderDetail.getAilightCount() - consumptionRequest.getConsumptionCount());
        } else {
            //要是被别人已经用了，就要重新找套餐
            productOrderDetail = deductionDepartmentProduct(consumptionRequest.getConsumptionCount(), consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
            if (productOrderDetail == null) {
                logger.info("业务编号:【{}】无可用套餐！", consumptionRequest.getBusinessId());
                return false;
            } else {
                //新套餐扣费
                productOrderDetail = productOrderDetailService.getById(detailId);
                productOrderDetail.setAilightCount(productOrderDetail.getAilightCount() - consumptionRequest.getConsumptionCount());
            }
        }
        //3.1扣费！
        boolean consumptionRe = productOrderDetailService.saveOrUpdate(productOrderDetail);
        if (consumptionRe) {
            //3.2扣费成功，写扣费记录
            ConsumptionRecord consumptionRecordNew = new ConsumptionRecord();
            consumptionRecordNew.setBusinessCode(ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION);
            consumptionRecordNew.setBusinessId(consumptionRequest.getBusinessId());
            consumptionRecordNew.setConsumptionCount(consumptionRequest.getConsumptionCount());
            consumptionRecordNew.setRecordType(ConsumptionConstant.DEDUCTION);
            consumptionRecordNew.setProOrderDetailId(productOrderDetail.getId());
            consumptionRecordNew.setLastRecordId(consumptionRecord.getId());
            consumptionRecordNew.setDiaId(consumptionRequest.getDiaId());
            consumptionRecordNew.setCreateTime(new Date());

            if (SaveConsumptionRecord(consumptionRecordNew)) {
                //3.3 扣费成功 同时更新预扣记录数据的套餐id和数据更新时间
                consumptionRecord.setProOrderDetailId(productOrderDetail.getId());
                consumptionRecord.setUpdateTime(new Date());
                if (SaveConsumptionRecord(consumptionRecord)) {
                    //消息队列通知
                    MessageToBI(consumptionRequest);
                    //已经扣费
                    logger.info("业务编号:【{}】该业务已经扣费！", consumptionRequest.getBusinessId());
                    return true;
                }
                else
                {
                    logger.info("业务编号:【{}】更新预扣费数据失败！", consumptionRequest.getBusinessId());
                }
            } else {
                logger.info("业务编号:【{}】预扣费执行失败！", consumptionRequest.getBusinessId());
            }
        } else {
            logger.info("业务编号:【{}】扣除套餐失败！", consumptionRequest.getBusinessId());
        }
        return false;
    }

    /**
     * 返回结果包装
     *
     * @param consumptionRequest 请求参数
     * @param bcode              返回码
     * @param reMsg              返回信息
     * @param isSuccess          业务执行是否成功
     * @return
     */
    private ResultBody ResultReturn(ConsumptionRequest consumptionRequest, int bcode, int recordType, String reMsg, boolean isSuccess) {
        //返回的数据实体
        ConsumptionVo consumptionVo = new ConsumptionVo();
        consumptionVo.setConsumptionCount(consumptionRequest.getConsumptionCount());
        consumptionVo.setBusinessId(consumptionRequest.getBusinessId());
        consumptionVo.setBcode(bcode);
        consumptionVo.setRecordType(recordType);
        logger.info("扣费业务返回参数实体："+consumptionRequest.toString());
        logger.info("扣费业务返回其他参数：bcode:{},recordType:{},reMsg:{},isSuccess:{}",bcode,recordType,reMsg,isSuccess);
        if (isSuccess) {
            return ResultBody.ok().data(consumptionVo).msg(reMsg);
        } else {
            return ResultBody.failed(reMsg).data(consumptionVo);
        }
    }

    /**
     * 预扣费业务
     *
     * @param consumptionRequest 请求参数
     * @return
     */
    private Boolean beforeConsumption(ConsumptionRequest consumptionRequest) {
        ProductOrderDetail productOrderDetail = deductionDepartmentProduct(consumptionRequest.getConsumptionCount(), consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
        if (productOrderDetail != null) {
            ConsumptionRecord consumptionRecord = new ConsumptionRecord();
            consumptionRecord.setBusinessCode(ConsumptionConstant.BUSINESS_CODE_IS_BEFORE_DEDUCTION);
            consumptionRecord.setBusinessId(consumptionRequest.getBusinessId());
            consumptionRecord.setConsumptionCount(consumptionRequest.getConsumptionCount());
            consumptionRecord.setRecordType(ConsumptionConstant.BEFORE_DEDUCTION);
            consumptionRecord.setProOrderDetailId(productOrderDetail.getId());
            consumptionRecord.setDiaId(consumptionRequest.getDiaId());
            if (SaveConsumptionRecord(consumptionRecord)) {
                return true;
            } else {
                logger.info("医院id:【{}】预扣费执行失败！", consumptionRequest.getHospitalId());
            }
        } else {
            logger.info("医院id:【{}】套餐获取失败！", consumptionRequest.getHospitalId());
        }
        return false;
    }

    /**
     * 参数验证
     */
    private Boolean VateParams(ConsumptionRequest consumptionRequest) {
        logger.info("收到扣费请求的参数："+consumptionRequest.toString());
        if (consumptionRequest != null) {
            //从请求头获取医院和科室id
            String hosId = consumptionRequest.getHospitalId().toString();
            String depId = consumptionRequest.getDepartmentId().toString();
            String doctorId = consumptionRequest.getDoctorId().toString();
            String diaId = consumptionRequest.getDiaId();
            if (StringUtils.isNotBlank(consumptionRequest.getBusinessId())
                    && consumptionRequest.getConsumptionCount() > 0
                    && StringUtils.isNotBlank(hosId)
                    && StringUtils.isNotBlank(depId)
                    && StringUtils.isNotBlank(doctorId)
                    && StringUtils.isNotBlank(diaId)) {
                return true;
            } else {
                logger.info("扣费请求参数不完整！");
            }
        } else {
            logger.info("扣费请求参数为空！");
        }
        return false;
    }

    /**
     * 检查余额够不够
     *
     * @param consumptionCount 要扣的数量
     * @return
     */
    private Map<String, Object> VateUserNowProduct(int consumptionCount, Long hospitalId, Long departmentId) {
        Map<String, Object> returnMap = new HashMap<>();
        ResultBody biUserPro = productOrderDetailService.biUserNowProduct(hospitalId, departmentId);
        if (biUserPro.getCode() == 0) {
            if (StringUtils.isNotBlank(biUserPro.getData().toString())) {
                //余额
                int userAICount = Integer.parseInt(biUserPro.getData().toString());
                if (userAICount >= consumptionCount) {
                    returnMap.put("vateRe", true);
                    returnMap.put("vateMsg", "余额足够!");
                } else {
                    returnMap.put("vateRe", false);
                    returnMap.put("vateMsg", "余额不足!");
                    logger.info("医院id:【{}】余额不足！", hospitalId);
                }
            } else {
                returnMap.put("vateRe", false);
                returnMap.put("vateMsg", "余额获取异常,data为空!");
                logger.info("医院id:【{}】余额获取异常！", hospitalId);
            }
        } else {
            returnMap.put("vateRe", false);
            returnMap.put("vateMsg", "余额获取异常,Code非0!");
            logger.info("医院id:【{}】余额获取异常,返回非0！", hospitalId);
        }
        return returnMap;
    }

    /**
     * 获取要使用的套餐实体
     *
     * @param consumCount 要使用的数量
     * @return
     */
    private ProductOrderDetail deductionDepartmentProduct(int consumCount, Long hospitalId, Long departmentId) {
        UserProductDetail userProductDetail = productOrderDetailService.getUserProductDetail(hospitalId, departmentId);
        //合并集合
        userProductDetail.getProductOrderJoinDetailListShare()
                .addAll(userProductDetail.getProductOrderJoinDetailsListDep());
        List<ProductOrderJoinDetail> productOrderJoinDetailList = userProductDetail.getProductOrderJoinDetailListShare();
        if (productOrderJoinDetailList.size() > 0) {
            //合并后按id排序并筛除已用完的套餐
            List<ProductOrderJoinDetail> productOrderJoinDetailsNewList = productOrderJoinDetailList
                    .stream().filter(f -> f.getAilightCount() >= consumCount).collect(Collectors.toList());
            //要使用的套餐信息
            Long firstId=productOrderJoinDetailsNewList.get(0).getId();
            logger.info("扣费要使用的套餐ID是id:【{}】", firstId);
            ProductOrderDetail productOrderDetail = productOrderDetailService.getById(firstId);
            return productOrderDetail;
        }
        return null;
    }

    /**
     * 写/更新记录数据
     *
     * @param consumptionRecord
     * @return
     */
    private Boolean SaveConsumptionRecord(ConsumptionRecord consumptionRecord) {
        if (consumptionRecord != null) {
            if (consumptionRecord.getCreateTime() == null) {
                consumptionRecord.setCreateTime(new Date());
            }
            return this.saveOrUpdate(consumptionRecord);
        } else {
            logger.info("扣费数据写入参数为空！");
        }
        return false;
    }

    /**
     * 检查该业务是否存在该业务类型
     *
     * @param consumptionRecordList 该业务下的扣费列表
     * @param recordType            记录类型编码 参考ConsumptionConstant里面
     * @return
     */
    private boolean isBeforeDeduction(List<ConsumptionRecord> consumptionRecordList, int recordType) {
        if (consumptionRecordList != null) {
            if (consumptionRecordList.size() > 0) {
                //过滤预扣费的记录
                return consumptionRecordList.stream().filter(f -> f.getRecordType() == recordType && f.getProOrderDetailId() > 0).collect(Collectors.toList()).size() == 1;
            }
        }
        return false;
    }

    /**
     * 获取一个业务关联的扣费记录
     * @param businessId 光片的名称/编号
     * @return
     */
    private List<ConsumptionRecord> GetBusinessConsumptionList(String businessId) {
        if (StringUtils.isNotBlank(businessId)) {
            Map<String, Object> params = new HashMap<>();
            params.put("businessId", businessId);
            List<ConsumptionRecord> consumptionRecordList = this.findAllList(params);
            return consumptionRecordList;
        }
        return null;
    }

    /**
     * 获取一个扣费记录
     *
     * @param recordId 扣费记录id
     * @return
     */
    private ConsumptionRecord GetBusinessConsumptionList(Long recordId) {
        if (recordId > 0) {
            return baseMapper.selectById(recordId);
        }
        return null;
    }

    /**
     * 发消息到消息队列
     *
     * @return
     */
    //@RabbitListener(queues = "BoneAgeEvaluationData")
    private void MessageToBI(ConsumptionRequest consumptionRequest) {
        //发消息到队列
        String context = "{\"hospitalId\":\"" + consumptionRequest.getHospitalId() +
                "\",\"departmentId\":\"" + consumptionRequest.getDepartmentId() +
                "\",\"doctorId\":\"" + consumptionRequest.getDoctorId() +
                "\",\"date\":\"" + DateUtils.formatDate(new Date(), "yyyy-MM-dd") + "\"}";
        rabbitTemplate.convertAndSend(ConsumptionConstant.EXCHANGE_DATA, ConsumptionConstant.ROUTINGKEY_DATA + envName, context);

        log.info("骨龄评价扣费消息已发送：" + context);
    }

    /**
     * 查看当前科室是否开通了单次支付
     *
     * @param consumptionRequest
     * @return
     */
    private Boolean departmentIsPay(ConsumptionRequest consumptionRequest) {
        log.info("查看当前科室是否开通了单次支付请求参数："+consumptionRequest.toString());
        PayManager payManager = payManagerService.findByObject(consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
        log.info("查看当前科室是否开通了单次支付请求查询后数据："+payManager.toString());
        if (payManager == null) {
            return false;
        } else {
            return payManager.getId()!=null;
        }
    }

    /**
     * 查看当前科室当前诊断id的支付状态是否成功
     *
     * @param consumptionRequest
     * @return
     */
    private Boolean departmentPayStatus(ConsumptionRequest consumptionRequest) {
        log.info("查看当前科室当前诊断id的支付状态是否成功请求参数："+consumptionRequest.toString());
        SaasClientPay saasClientPay = saasClientPayService.findModelByObject(consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId(), consumptionRequest.getDiaId());
        log.info("查看当前科室当前诊断id的支付状态是否成功查询后数据："+saasClientPay.toString());
        if (saasClientPay == null) {
            return false;
        } else {
            if (saasClientPay.getPayStatus().equals(PayConstants.ORDER_PAY_SUCEESS)) {
                return true;
            }
        }
        return false;
    }
}